#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*/ limpaVetor(char *);
int strlen(char *);
char *HexDecoder(char HexStr[]) {
  char strReslt[strlen(HexStr)];
  int i, j, hexp;
  limpaVetor(strReslt);
  for (i = 0, j = 0;
       HexStr[i] != '\r' && HexStr[i] != '\n' && HexStr[i] != '\0';
       i += 2, j++) {
    switch (HexStr[i]) {
    case '0':
      HexStr[i] = 0;
      break;
    case '1':
      HexStr[i] = 1;
      break;
    case '2':
      HexStr[i] = 2;
      break;
    case '3':
      HexStr[i] = 3;
      break;
    case '4':
      HexStr[i] = 4;
      break;
    case '5':
      HexStr[i] = 5;
      break;
    case '6':
      HexStr[i] = 6;
      break;
    case '7':
      HexStr[i] = 7;
      break;
    case '8':
      HexStr[i] = 8;
      break;
    case '9':
      HexStr[i] = 9;
      break;
    case 'A':
      HexStr[i] = 10;
      break;
    case 'B':
      HexStr[i] = 11;
      break;
    case 'C':
      HexStr[i] = 12;
      break;
    case 'D':
      HexStr[i] = 13;
      break;
    case 'E':
      HexStr[i] = 14;
      break;
    case 'F':
      HexStr[i] = 15;
      break;
    }
    switch (HexStr[i + 1]) {
    case '0':
      HexStr[i + 1] = 0;
      break;
    case '1':
      HexStr[i + 1] = 1;
      break;
    case '2':
      HexStr[i + 1] = 2;
      break;
    case '3':
      HexStr[i + 1] = 3;
      break;
    case '4':
      HexStr[i + 1] = 4;
      break;
    case '5':
      HexStr[i + 1] = 5;
      break;
    case '6':
      HexStr[i + 1] = 6;
      break;
    case '7':
      HexStr[i + 1] = 7;
      break;
    case '8':
      HexStr[i + 1] = 8;
      break;
    case '9':
      HexStr[i + 1] = 9;
      break;
    case 'A':
      HexStr[i + 1] = 10;
      break;
    case 'B':
      HexStr[i + 1] = 11;
      break;
    case 'C':
      HexStr[i + 1] = 12;
      break;
    case 'D':
      HexStr[i + 1] = 13;
      break;
    case 'E':
      HexStr[i + 1] = 14;
      break;
    case 'F':
      HexStr[i + 1] = 15;
      break;
    }
    hexp = (HexStr[i] * 16) + HexStr[i + 1];
    strReslt[j] = hexp;
  }
  return strReslt;
}


x86 assembly (clang, -O0):
<HexDecoder>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,%eax
mov    %rsp,%rcx
mov    %rcx,-0x10(%rbp)
mov    %rax,%rcx
add    $0xf,%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rdi
sub    %rcx,%rdi
mov    %rdi,-0x30(%rbp)
mov    %rdi,%rsp
mov    %rax,-0x18(%rbp)
call   1040 <limpaVetor@plt>
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0xd,%ecx
mov    %al,-0x31(%rbp)
je     11b6 <HexDecoder+0x96>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%ecx
xor    %eax,%eax
cmp    $0xa,%ecx
mov    %al,-0x31(%rbp)
je     11b6 <HexDecoder+0x96>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x0,%eax
setne  %al
mov    %al,-0x31(%rbp)
mov    -0x31(%rbp),%al
test   $0x1,%al
jne    11c6 <HexDecoder+0xa6>
jmp    14dd <HexDecoder+0x3bd>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
add    $0xffffffd0,%eax
mov    %eax,%ecx
mov    %rcx,-0x40(%rbp)
sub    $0x16,%eax
ja     1303 <HexDecoder+0x1e3>
mov    -0x40(%rbp),%rax
lea    0xe11(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    1303 <HexDecoder+0x1e3>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x1,(%rax,%rcx,1)
jmp    1303 <HexDecoder+0x1e3>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x2,(%rax,%rcx,1)
jmp    1303 <HexDecoder+0x1e3>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x3,(%rax,%rcx,1)
jmp    1303 <HexDecoder+0x1e3>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x4,(%rax,%rcx,1)
jmp    1303 <HexDecoder+0x1e3>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x5,(%rax,%rcx,1)
jmp    1303 <HexDecoder+0x1e3>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x6,(%rax,%rcx,1)
jmp    1303 <HexDecoder+0x1e3>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x7,(%rax,%rcx,1)
jmp    1303 <HexDecoder+0x1e3>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x8,(%rax,%rcx,1)
jmp    1303 <HexDecoder+0x1e3>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x9,(%rax,%rcx,1)
jmp    1303 <HexDecoder+0x1e3>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0xa,(%rax,%rcx,1)
jmp    1303 <HexDecoder+0x1e3>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0xb,(%rax,%rcx,1)
jmp    1303 <HexDecoder+0x1e3>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0xc,(%rax,%rcx,1)
jmp    1303 <HexDecoder+0x1e3>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0xd,(%rax,%rcx,1)
jmp    1303 <HexDecoder+0x1e3>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0xe,(%rax,%rcx,1)
jmp    1303 <HexDecoder+0x1e3>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0xf,(%rax,%rcx,1)
mov    -0x8(%rbp),%rcx
movslq -0x1c(%rbp),%rax
movsbl 0x1(%rax,%rcx,1),%eax
add    $0xffffffd0,%eax
mov    %eax,%ecx
mov    %rcx,-0x48(%rbp)
sub    $0x16,%eax
ja     1491 <HexDecoder+0x371>
mov    -0x48(%rbp),%rax
lea    0xd2f(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x0,(%rax,%rcx,1)
jmp    1491 <HexDecoder+0x371>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x1,(%rax,%rcx,1)
jmp    1491 <HexDecoder+0x371>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x2,(%rax,%rcx,1)
jmp    1491 <HexDecoder+0x371>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x3,(%rax,%rcx,1)
jmp    1491 <HexDecoder+0x371>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x4,(%rax,%rcx,1)
jmp    1491 <HexDecoder+0x371>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x5,(%rax,%rcx,1)
jmp    1491 <HexDecoder+0x371>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x6,(%rax,%rcx,1)
jmp    1491 <HexDecoder+0x371>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x7,(%rax,%rcx,1)
jmp    1491 <HexDecoder+0x371>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x8,(%rax,%rcx,1)
jmp    1491 <HexDecoder+0x371>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0x9,(%rax,%rcx,1)
jmp    1491 <HexDecoder+0x371>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0xa,(%rax,%rcx,1)
jmp    1491 <HexDecoder+0x371>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0xb,(%rax,%rcx,1)
jmp    1491 <HexDecoder+0x371>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0xc,(%rax,%rcx,1)
jmp    1491 <HexDecoder+0x371>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0xd,(%rax,%rcx,1)
jmp    1491 <HexDecoder+0x371>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0xe,(%rax,%rcx,1)
jmp    1491 <HexDecoder+0x371>
mov    -0x8(%rbp),%rax
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movb   $0xf,(%rax,%rcx,1)
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
shl    $0x4,%ecx
mov    -0x8(%rbp),%rdx
mov    -0x1c(%rbp),%esi
add    $0x1,%esi
movslq %esi,%rsi
movsbl (%rdx,%rsi,1),%edx
add    %edx,%ecx
mov    %ecx,-0x24(%rbp)
mov    -0x24(%rbp),%ecx
mov    %cl,%dl
movslq -0x20(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    116d <HexDecoder+0x4d>
mov    -0x30(%rbp),%rax
mov    -0x10(%rbp),%rcx
mov    %rcx,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<HexDecoder>:
push   %rbp
mov    %rsp,%rbp
push   %r14
push   %rbx
mov    %rdi,%rbx
call   1030 <strlen@plt>
mov    %eax,%eax
mov    %rsp,%r14
add    $0xf,%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r14
mov    %r14,%rsp
mov    %r14,%rdi
call   1040 <limpaVetor@plt>
xor    %eax,%eax
mov    $0x7e03ff,%ecx
lea    0xea8(%rip),%r8
mov    $0x2401,%r9d
jmp    116f <HexDecoder+0x4f>
shl    $0x4,%dil
add    %sil,%dil
mov    %dil,(%r14,%rax,1)
add    $0x1,%rax
movzbl (%rbx,%rax,2),%edi
cmp    $0xd,%rdi
ja     117f <HexDecoder+0x5f>
bt     %rdi,%r9
jb     11bd <HexDecoder+0x9d>
movsbq %dil,%rdx
add    $0xffffffffffffffd0,%rdx
cmp    $0x16,%edx
ja     119a <HexDecoder+0x7a>
bt     %edx,%ecx
jae    119a <HexDecoder+0x7a>
movzbl (%rdx,%r8,1),%edi
mov    %dil,(%rbx,%rax,2)
movsbq 0x1(%rbx,%rax,2),%rsi
mov    %rsi,%rdx
add    $0xffffffffffffffd0,%rdx
cmp    $0x16,%edx
ja     1160 <HexDecoder+0x40>
bt     %edx,%ecx
jae    1160 <HexDecoder+0x40>
movzbl (%rdx,%r8,1),%esi
mov    %sil,0x1(%rbx,%rax,2)
jmp    1160 <HexDecoder+0x40>
mov    %r14,%rax
lea    -0x10(%rbp),%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

LLVM IR (-O0):
define i8* @HexDecoder(i8* %0) {
%2 = alloca i8*
%3 = alloca i8*
%4 = alloca i64
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
store i8* %0, i8** %2
%8 = load i8*, i8** %2
%9 = call i32 @strlen(i8* %8)
%10 = zext i32 %9 to i64
%11 = call i8* @llvm.stacksave()
store i8* %11, i8** %3
%12 = alloca i8, i64 %10
store i64 %10, i64* %4
%13 = call i32 @limpaVetor(i8* %12)
store i32 0, i32* %5
store i32 0, i32* %6
br label %14
14: ; preds = %252, %1
%15 = load i8*, i8** %2
%16 = load i32, i32* %5
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds i8, i8* %15, i64 %17
%19 = load i8, i8* %18
%20 = sext i8 %19 to i32
%21 = icmp ne i32 %20, 13
br i1 %21, label %22, label %38
22: ; preds = %14
%23 = load i8*, i8** %2
%24 = load i32, i32* %5
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds i8, i8* %23, i64 %25
%27 = load i8, i8* %26
%28 = sext i8 %27 to i32
%29 = icmp ne i32 %28, 10
br i1 %29, label %30, label %38
30: ; preds = %22
%31 = load i8*, i8** %2
%32 = load i32, i32* %5
%33 = sext i32 %32 to i64
%34 = getelementptr inbounds i8, i8* %31, i64 %33
%35 = load i8, i8* %34
%36 = sext i8 %35 to i32
%37 = icmp ne i32 %36, 0
br label %38
38: ; preds = %30, %22, %14
%39 = phi i1 [ false, %22 ], [ false, %14 ], [ %37, %30 ]
br i1 %39, label %40, label %257
40: ; preds = %38
%41 = load i8*, i8** %2
%42 = load i32, i32* %5
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i8, i8* %41, i64 %43
%45 = load i8, i8* %44
%46 = sext i8 %45 to i32
switch i32 %46, label %127 [
i32 48, label %47
i32 49, label %52
i32 50, label %57
i32 51, label %62
i32 52, label %67
i32 53, label %72
i32 54, label %77
i32 55, label %82
i32 56, label %87
i32 57, label %92
i32 65, label %97
i32 66, label %102
i32 67, label %107
i32 68, label %112
i32 69, label %117
i32 70, label %122
]
47: ; preds = %40
%48 = load i8*, i8** %2
%49 = load i32, i32* %5
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds i8, i8* %48, i64 %50
store i8 0, i8* %51
br label %127
52: ; preds = %40
%53 = load i8*, i8** %2
%54 = load i32, i32* %5
%55 = sext i32 %54 to i64
%56 = getelementptr inbounds i8, i8* %53, i64 %55
store i8 1, i8* %56
br label %127
57: ; preds = %40
%58 = load i8*, i8** %2
%59 = load i32, i32* %5
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i8, i8* %58, i64 %60
store i8 2, i8* %61
br label %127
62: ; preds = %40
%63 = load i8*, i8** %2
%64 = load i32, i32* %5
%65 = sext i32 %64 to i64
%66 = getelementptr inbounds i8, i8* %63, i64 %65
store i8 3, i8* %66
br label %127
67: ; preds = %40
%68 = load i8*, i8** %2
%69 = load i32, i32* %5
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds i8, i8* %68, i64 %70
store i8 4, i8* %71
br label %127
72: ; preds = %40
%73 = load i8*, i8** %2
%74 = load i32, i32* %5
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i8, i8* %73, i64 %75
store i8 5, i8* %76
br label %127
77: ; preds = %40
%78 = load i8*, i8** %2
%79 = load i32, i32* %5
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i8, i8* %78, i64 %80
store i8 6, i8* %81
br label %127
82: ; preds = %40
%83 = load i8*, i8** %2
%84 = load i32, i32* %5
%85 = sext i32 %84 to i64
%86 = getelementptr inbounds i8, i8* %83, i64 %85
store i8 7, i8* %86
br label %127
87: ; preds = %40
%88 = load i8*, i8** %2
%89 = load i32, i32* %5
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds i8, i8* %88, i64 %90
store i8 8, i8* %91
br label %127
92: ; preds = %40
%93 = load i8*, i8** %2
%94 = load i32, i32* %5
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds i8, i8* %93, i64 %95
store i8 9, i8* %96
br label %127
97: ; preds = %40
%98 = load i8*, i8** %2
%99 = load i32, i32* %5
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i8, i8* %98, i64 %100
store i8 10, i8* %101
br label %127
102: ; preds = %40
%103 = load i8*, i8** %2
%104 = load i32, i32* %5
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds i8, i8* %103, i64 %105
store i8 11, i8* %106
br label %127
107: ; preds = %40
%108 = load i8*, i8** %2
%109 = load i32, i32* %5
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds i8, i8* %108, i64 %110
store i8 12, i8* %111
br label %127
112: ; preds = %40
%113 = load i8*, i8** %2
%114 = load i32, i32* %5
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds i8, i8* %113, i64 %115
store i8 13, i8* %116
br label %127
117: ; preds = %40
%118 = load i8*, i8** %2
%119 = load i32, i32* %5
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds i8, i8* %118, i64 %120
store i8 14, i8* %121
br label %127
122: ; preds = %40
%123 = load i8*, i8** %2
%124 = load i32, i32* %5
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds i8, i8* %123, i64 %125
store i8 15, i8* %126
br label %127
127: ; preds = %40, %122, %117, %112, %107, %102, %97, %92, %87, %82, %77, %72, %67, %62, %57, %52, %47
%128 = load i8*, i8** %2
%129 = load i32, i32* %5
%130 = add nsw i32 %129, 1
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds i8, i8* %128, i64 %131
%133 = load i8, i8* %132
%134 = sext i8 %133 to i32
switch i32 %134, label %231 [
i32 48, label %135
i32 49, label %141
i32 50, label %147
i32 51, label %153
i32 52, label %159
i32 53, label %165
i32 54, label %171
i32 55, label %177
i32 56, label %183
i32 57, label %189
i32 65, label %195
i32 66, label %201
i32 67, label %207
i32 68, label %213
i32 69, label %219
i32 70, label %225
]
135: ; preds = %127
%136 = load i8*, i8** %2
%137 = load i32, i32* %5
%138 = add nsw i32 %137, 1
%139 = sext i32 %138 to i64
%140 = getelementptr inbounds i8, i8* %136, i64 %139
store i8 0, i8* %140
br label %231
141: ; preds = %127
%142 = load i8*, i8** %2
%143 = load i32, i32* %5
%144 = add nsw i32 %143, 1
%145 = sext i32 %144 to i64
%146 = getelementptr inbounds i8, i8* %142, i64 %145
store i8 1, i8* %146
br label %231
147: ; preds = %127
%148 = load i8*, i8** %2
%149 = load i32, i32* %5
%150 = add nsw i32 %149, 1
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds i8, i8* %148, i64 %151
store i8 2, i8* %152
br label %231
153: ; preds = %127
%154 = load i8*, i8** %2
%155 = load i32, i32* %5
%156 = add nsw i32 %155, 1
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds i8, i8* %154, i64 %157
store i8 3, i8* %158
br label %231
159: ; preds = %127
%160 = load i8*, i8** %2
%161 = load i32, i32* %5
%162 = add nsw i32 %161, 1
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i8, i8* %160, i64 %163
store i8 4, i8* %164
br label %231
165: ; preds = %127
%166 = load i8*, i8** %2
%167 = load i32, i32* %5
%168 = add nsw i32 %167, 1
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds i8, i8* %166, i64 %169
store i8 5, i8* %170
br label %231
171: ; preds = %127
%172 = load i8*, i8** %2
%173 = load i32, i32* %5
%174 = add nsw i32 %173, 1
%175 = sext i32 %174 to i64
%176 = getelementptr inbounds i8, i8* %172, i64 %175
store i8 6, i8* %176
br label %231
177: ; preds = %127
%178 = load i8*, i8** %2
%179 = load i32, i32* %5
%180 = add nsw i32 %179, 1
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i8, i8* %178, i64 %181
store i8 7, i8* %182
br label %231
183: ; preds = %127
%184 = load i8*, i8** %2
%185 = load i32, i32* %5
%186 = add nsw i32 %185, 1
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds i8, i8* %184, i64 %187
store i8 8, i8* %188
br label %231
189: ; preds = %127
%190 = load i8*, i8** %2
%191 = load i32, i32* %5
%192 = add nsw i32 %191, 1
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds i8, i8* %190, i64 %193
store i8 9, i8* %194
br label %231
195: ; preds = %127
%196 = load i8*, i8** %2
%197 = load i32, i32* %5
%198 = add nsw i32 %197, 1
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds i8, i8* %196, i64 %199
store i8 10, i8* %200
br label %231
201: ; preds = %127
%202 = load i8*, i8** %2
%203 = load i32, i32* %5
%204 = add nsw i32 %203, 1
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds i8, i8* %202, i64 %205
store i8 11, i8* %206
br label %231
207: ; preds = %127
%208 = load i8*, i8** %2
%209 = load i32, i32* %5
%210 = add nsw i32 %209, 1
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds i8, i8* %208, i64 %211
store i8 12, i8* %212
br label %231
213: ; preds = %127
%214 = load i8*, i8** %2
%215 = load i32, i32* %5
%216 = add nsw i32 %215, 1
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds i8, i8* %214, i64 %217
store i8 13, i8* %218
br label %231
219: ; preds = %127
%220 = load i8*, i8** %2
%221 = load i32, i32* %5
%222 = add nsw i32 %221, 1
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds i8, i8* %220, i64 %223
store i8 14, i8* %224
br label %231
225: ; preds = %127
%226 = load i8*, i8** %2
%227 = load i32, i32* %5
%228 = add nsw i32 %227, 1
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds i8, i8* %226, i64 %229
store i8 15, i8* %230
br label %231
231: ; preds = %127, %225, %219, %213, %207, %201, %195, %189, %183, %177, %171, %165, %159, %153, %147, %141, %135
%232 = load i8*, i8** %2
%233 = load i32, i32* %5
%234 = sext i32 %233 to i64
%235 = getelementptr inbounds i8, i8* %232, i64 %234
%236 = load i8, i8* %235
%237 = sext i8 %236 to i32
%238 = mul nsw i32 %237, 16
%239 = load i8*, i8** %2
%240 = load i32, i32* %5
%241 = add nsw i32 %240, 1
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds i8, i8* %239, i64 %242
%244 = load i8, i8* %243
%245 = sext i8 %244 to i32
%246 = add nsw i32 %238, %245
store i32 %246, i32* %7
%247 = load i32, i32* %7
%248 = trunc i32 %247 to i8
%249 = load i32, i32* %6
%250 = sext i32 %249 to i64
%251 = getelementptr inbounds i8, i8* %12, i64 %250
store i8 %248, i8* %251
br label %252
252: ; preds = %231
%253 = load i32, i32* %5
%254 = add nsw i32 %253, 2
store i32 %254, i32* %5
%255 = load i32, i32* %6
%256 = add nsw i32 %255, 1
store i32 %256, i32* %6
br label %14
257: ; preds = %38
%258 = load i8*, i8** %3
ret i8* %12
}

LLVM IR (-O2):
@switch.table.HexDecoder.1 = [23 x i8] c"\00\01\02\03\04\05\06\07\08\09\00\00\00\00\00\00\00\0A\0B\0C\0D\0E\0F"
define i8* @HexDecoder(i8* %0) {
%2 = tail call i32 @strlen(i8* %0)
%3 = zext i32 %2 to i64
%4 = alloca i8, i64 %3
%5 = call i32 @limpaVetor(i8* %4)
br label %6
6: ; preds = %39, %1
%7 = phi i64 [ %44, %39 ], [ 0, %1 ]
%8 = phi i64 [ %45, %39 ], [ 0, %1 ]
%9 = getelementptr inbounds i8, i8* %0, i64 %7
%10 = load i8, i8* %9
switch i8 %10, label %11 [
i8 13, label %46
i8 10, label %46
i8 0, label %46
]
11: ; preds = %6
%12 = sext i8 %10 to i32
%13 = add nsw i32 %12, -48
%14 = icmp ult i32 %13, 23
br i1 %14, label %15, label %23
15: ; preds = %11
%16 = lshr i32 8258559, %13
%17 = and i32 %16, 1
%18 = icmp eq i32 %17, 0
br i1 %18, label %23, label %19
19: ; preds = %15
%20 = sext i32 %13 to i64
%21 = getelementptr inbounds [23 x i8], [23 x i8]* @switch.table.HexDecoder.1, i64 0, i64 %20
%22 = load i8, i8* %21
store i8 %22, i8* %9
br label %23
23: ; preds = %15, %11, %19
%24 = phi i8 [ %10, %11 ], [ %22, %19 ], [ %10, %15 ]
%25 = or i64 %7, 1
%26 = getelementptr inbounds i8, i8* %0, i64 %25
%27 = load i8, i8* %26
%28 = sext i8 %27 to i32
%29 = add nsw i32 %28, -48
%30 = icmp ult i32 %29, 23
br i1 %30, label %31, label %39
31: ; preds = %23
%32 = lshr i32 8258559, %29
%33 = and i32 %32, 1
%34 = icmp eq i32 %33, 0
br i1 %34, label %39, label %35
35: ; preds = %31
%36 = sext i32 %29 to i64
%37 = getelementptr inbounds [23 x i8], [23 x i8]* @switch.table.HexDecoder.1, i64 0, i64 %36
%38 = load i8, i8* %37
store i8 %38, i8* %26
br label %39
39: ; preds = %31, %23, %35
%40 = phi i8 [ %27, %23 ], [ %38, %35 ], [ %27, %31 ]
%41 = shl i8 %24, 4
%42 = add i8 %41, %40
%43 = getelementptr inbounds i8, i8* %4, i64 %8
store i8 %42, i8* %43
%44 = add nuw i64 %7, 2
%45 = add nuw i64 %8, 1
br label %6
46: ; preds = %6, %6, %6
ret i8* %4
}