#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 *Copy_Not_Encoded_String(char *, char *);
char *Decode_String(char *, char *);
int /*<<< orphan*/ Quote_If_Needed(char *);
scalar_t__ isalnum(char);
scalar_t__ isdigit(char);
char *strstr(char *, char *);
int strtol(char *, char **, int);
int strtoul(char *, char **, int);
char *Decode_Hexa(char *str, int strict, int quote, int decode_aux,
                  char *module, char *pred, int *arity, int *aux_no) {
  int n;
  int module_encode;
  int pred_encode;
  char *p, *q;
  if (*str++ != 'X' || *str < '0' || *str >= '5')
    return NULL;
  n = *str++ - '0';
  module_encode = n >> 1;
  pred_encode = n & 1;
  if (*str++ != '_')
    return NULL;
  if (module_encode == 0)
    *module = '\0';
  else {
    str = (module_encode == 1) ? Copy_Not_Encoded_String(str, module)
                               : Decode_String(str, module);
    if (str == NULL || *str++ != '_' || *str++ != '_')
      return NULL;
    if (quote)
      Quote_If_Needed(module);
  }
  str = (pred_encode == 0) ? Copy_Not_Encoded_String(str, pred)
                           : Decode_String(str, pred);
  if (str == NULL || *pred == '\0')
    return NULL;
  *arity = -1;
  if (*str == '_' && str[1] == '_' && str[2] == 'a') {
    *arity = strtoul(str + 3, &p, 10);
    if (p == str + 3)
      *arity = -1;
    str = p;
  }
  if (*arity < 0 || *arity > 1024 || isalnum(*p) || *p == '_') {
    if (strict)
      return NULL;
    *arity = -1;
  }
  *aux_no = -1;
  if (decode_aux && *pred == '$' && (p = strstr(pred, "_$aux")) != NULL) {
    n = strtol(p + sizeof("_$aux") - 1, &q, 10);
    if (*q == '\0') {
      while (--p > pred && isdigit(*p))
        ;
      if (p >= pred && *p == '/') {
        *aux_no = n;
        *p = '\0';
        *arity = strtol(p + 1, &p, 10);
        p = pred;
        do
          *p = p[1];
        while (*p++);
      }
    }
  }
  if (quote)
    Quote_If_Needed(pred);
  return str;
}


x86 assembly (clang, -O0):
<Decode_Hexa>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %edx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movsbl (%rax),%eax
cmp    $0x58,%eax
jne    11e0 <Decode_Hexa+0x60>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x30,%eax
jl     11e0 <Decode_Hexa+0x60>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x35,%eax
jl     11ed <Decode_Hexa+0x6d>
movq   $0x0,-0x8(%rbp)
jmp    1597 <Decode_Hexa+0x417>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movsbl (%rax),%eax
sub    $0x30,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
sar    $0x1,%eax
mov    %eax,-0x38(%rbp)
mov    -0x34(%rbp),%eax
and    $0x1,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movsbl (%rax),%eax
cmp    $0x5f,%eax
je     123f <Decode_Hexa+0xbf>
movq   $0x0,-0x8(%rbp)
jmp    1597 <Decode_Hexa+0x417>
cmpl   $0x0,-0x38(%rbp)
jne    1255 <Decode_Hexa+0xd5>
mov    -0x28(%rbp),%rax
movb   $0x0,(%rax)
jmp    12f4 <Decode_Hexa+0x174>
cmpl   $0x1,-0x38(%rbp)
jne    1275 <Decode_Hexa+0xf5>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   1070 <Copy_Not_Encoded_String@plt>
mov    %rax,-0x58(%rbp)
jmp    1286 <Decode_Hexa+0x106>
mov    -0x10(%rbp),%rdi
mov    -0x28(%rbp),%rsi
call   1080 <Decode_String@plt>
mov    %rax,-0x58(%rbp)
mov    -0x58(%rbp),%rax
mov    %rax,-0x10(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     12cf <Decode_Hexa+0x14f>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movsbl (%rax),%eax
cmp    $0x5f,%eax
jne    12cf <Decode_Hexa+0x14f>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movsbl (%rax),%eax
cmp    $0x5f,%eax
je     12dc <Decode_Hexa+0x15c>
movq   $0x0,-0x8(%rbp)
jmp    1597 <Decode_Hexa+0x417>
cmpl   $0x0,-0x18(%rbp)
je     12ef <Decode_Hexa+0x16f>
mov    -0x28(%rbp),%rdi
call   1040 <Quote_If_Needed@plt>
jmp    12f4 <Decode_Hexa+0x174>
cmpl   $0x0,-0x3c(%rbp)
jne    1314 <Decode_Hexa+0x194>
mov    -0x10(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   1070 <Copy_Not_Encoded_String@plt>
mov    %rax,-0x60(%rbp)
jmp    1325 <Decode_Hexa+0x1a5>
mov    -0x10(%rbp),%rdi
mov    -0x30(%rbp),%rsi
call   1080 <Decode_String@plt>
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x10(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1348 <Decode_Hexa+0x1c8>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    1355 <Decode_Hexa+0x1d5>
movq   $0x0,-0x8(%rbp)
jmp    1597 <Decode_Hexa+0x417>
mov    0x10(%rbp),%rax
movl   $0xffffffff,(%rax)
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5f,%eax
jne    13d6 <Decode_Hexa+0x256>
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
cmp    $0x5f,%eax
jne    13d6 <Decode_Hexa+0x256>
mov    -0x10(%rbp),%rax
movsbl 0x2(%rax),%eax
cmp    $0x61,%eax
jne    13d6 <Decode_Hexa+0x256>
mov    -0x10(%rbp),%rdi
add    $0x3,%rdi
lea    -0x48(%rbp),%rsi
mov    $0xa,%edx
call   1090 <strtoul@plt>
mov    %eax,%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x48(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    $0x3,%rcx
cmp    %rcx,%rax
jne    13ce <Decode_Hexa+0x24e>
mov    0x10(%rbp),%rax
movl   $0xffffffff,(%rax)
mov    -0x48(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    0x10(%rbp),%rax
cmpl   $0x0,(%rax)
jl     1419 <Decode_Hexa+0x299>
mov    0x10(%rbp),%rax
cmpl   $0x400,(%rax)
jg     1419 <Decode_Hexa+0x299>
mov    -0x48(%rbp),%rax
movsbl (%rax),%edi
call   1050 <isalnum@plt>
cmp    $0x0,%rax
jne    1419 <Decode_Hexa+0x299>
mov    -0x48(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5f,%eax
jne    143a <Decode_Hexa+0x2ba>
cmpl   $0x0,-0x14(%rbp)
je     1430 <Decode_Hexa+0x2b0>
movq   $0x0,-0x8(%rbp)
jmp    1597 <Decode_Hexa+0x417>
mov    0x10(%rbp),%rax
movl   $0xffffffff,(%rax)
mov    0x18(%rbp),%rax
movl   $0xffffffff,(%rax)
cmpl   $0x0,-0x1c(%rbp)
je     157c <Decode_Hexa+0x3fc>
mov    -0x30(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x24,%eax
jne    157c <Decode_Hexa+0x3fc>
mov    -0x30(%rbp),%rdi
lea    0xb97(%rip),%rsi
call   10a0 <strstr@plt>
mov    %rax,-0x48(%rbp)
cmp    $0x0,%rax
je     157c <Decode_Hexa+0x3fc>
mov    -0x48(%rbp),%rdi
add    $0x6,%rdi
add    $0xffffffffffffffff,%rdi
lea    -0x50(%rbp),%rsi
mov    $0xa,%edx
call   1060 <strtol@plt>
mov    %eax,-0x34(%rbp)
mov    -0x50(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x0,%eax
jne    1577 <Decode_Hexa+0x3f7>
jmp    14ae <Decode_Hexa+0x32e>
mov    -0x48(%rbp),%rcx
add    $0xffffffffffffffff,%rcx
mov    %rcx,-0x48(%rbp)
xor    %eax,%eax
cmp    -0x30(%rbp),%rcx
mov    %al,-0x61(%rbp)
jbe    14df <Decode_Hexa+0x35f>
mov    -0x48(%rbp),%rax
movsbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%rax
setne  %al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
test   $0x1,%al
jne    14ef <Decode_Hexa+0x36f>
jmp    14f4 <Decode_Hexa+0x374>
jmp    14ae <Decode_Hexa+0x32e>
mov    -0x48(%rbp),%rax
cmp    -0x30(%rbp),%rax
jb     1572 <Decode_Hexa+0x3f2>
mov    -0x48(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x2f,%eax
jne    1572 <Decode_Hexa+0x3f2>
mov    -0x34(%rbp),%ecx
mov    0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x48(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x48(%rbp),%rdi
add    $0x1,%rdi
lea    -0x48(%rbp),%rsi
mov    $0xa,%edx
call   1060 <strtol@plt>
mov    %eax,%ecx
mov    0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x30(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
mov    0x1(%rax),%cl
mov    -0x48(%rbp),%rax
mov    %cl,(%rax)
mov    -0x48(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x48(%rbp)
cmpb   $0x0,(%rax)
jne    1548 <Decode_Hexa+0x3c8>
jmp    1572 <Decode_Hexa+0x3f2>
jmp    1577 <Decode_Hexa+0x3f7>
jmp    157c <Decode_Hexa+0x3fc>
cmpl   $0x0,-0x18(%rbp)
je     158f <Decode_Hexa+0x40f>
mov    -0x30(%rbp),%rdi
call   1040 <Quote_If_Needed@plt>
mov    -0x10(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Decode_Hexa>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
cmpb   $0x58,(%rdi)
jne    13ae <Decode_Hexa+0x22e>
mov    %rdi,%rbp
movsbl 0x1(%rdi),%r14d
lea    -0x35(%r14),%eax
cmp    $0xfb,%al
jb     13ae <Decode_Hexa+0x22e>
cmpb   $0x5f,0x2(%rbp)
jne    13ae <Decode_Hexa+0x22e>
mov    %r9,%r15
mov    %r8,%rbx
mov    %ecx,%r12d
mov    %esi,%r13d
lea    -0x30(%r14),%eax
add    $0x3,%rbp
cmp    $0x1,%eax
mov    %edx,0x4(%rsp)
ja     11e8 <Decode_Hexa+0x68>
movb   $0x0,(%rbx)
mov    %rbp,%rdi
mov    %r15,%rsi
test   $0x1,%r14b
jne    1204 <Decode_Hexa+0x84>
call   1070 <Copy_Not_Encoded_String@plt>
jmp    1209 <Decode_Hexa+0x89>
and    $0xfffffffe,%eax
mov    %rbp,%rdi
mov    %rbx,%rsi
cmp    $0x2,%eax
jne    1378 <Decode_Hexa+0x1f8>
call   1070 <Copy_Not_Encoded_String@plt>
jmp    137d <Decode_Hexa+0x1fd>
call   1080 <Decode_String@plt>
mov    %rax,%rbp
test   %rax,%rax
mov    0x4(%rsp),%ecx
je     13ae <Decode_Hexa+0x22e>
cmpb   $0x0,(%r15)
je     13ae <Decode_Hexa+0x22e>
mov    0x50(%rsp),%r14
movl   $0xffffffff,(%r14)
cmpb   $0x5f,0x0(%rbp)
jne    128b <Decode_Hexa+0x10b>
cmpb   $0x5f,0x1(%rbp)
jne    128b <Decode_Hexa+0x10b>
cmpb   $0x61,0x2(%rbp)
jne    128b <Decode_Hexa+0x10b>
mov    %rbp,%rbx
add    $0x3,%rbx
lea    0x8(%rsp),%rsi
mov    %rbx,%rdi
mov    $0xa,%edx
call   1090 <strtoul@plt>
mov    0x8(%rsp),%rbp
cmp    %rbx,%rbp
mov    $0xffffffff,%ecx
cmovne %eax,%ecx
mov    %ecx,(%r14)
cmp    $0x400,%ecx
ja     1287 <Decode_Hexa+0x107>
movsbl 0x0(%rbp),%edi
call   1050 <isalnum@plt>
test   %rax,%rax
je     13c2 <Decode_Hexa+0x242>
mov    0x4(%rsp),%ecx
test   %r13d,%r13d
jne    13ae <Decode_Hexa+0x22e>
movl   $0xffffffff,(%r14)
mov    0x58(%rsp),%r14
movl   $0xffffffff,(%r14)
test   %r12d,%r12d
je     136a <Decode_Hexa+0x1ea>
cmpb   $0x24,(%r15)
jne    136a <Decode_Hexa+0x1ea>
lea    0xd3f(%rip),%rsi
mov    %r15,%rdi
call   10a0 <strstr@plt>
mov    0x4(%rsp),%ecx
test   %rax,%rax
je     136a <Decode_Hexa+0x1ea>
mov    %rax,%r13
lea    0x5(%rax),%rdi
lea    0x10(%rsp),%rsi
mov    $0xa,%edx
call   1060 <strtol@plt>
mov    0x4(%rsp),%ecx
mov    %eax,%r12d
mov    0x10(%rsp),%rax
cmpb   $0x0,(%rax)
jne    136a <Decode_Hexa+0x1ea>
add    $0xffffffffffffffff,%r13
mov    %r13,%rbx
cmp    %r15,%r13
jbe    131a <Decode_Hexa+0x19a>
movsbl (%rbx),%edi
call   1030 <isdigit@plt>
lea    -0x1(%rbx),%r13
test   %rax,%rax
jne    1301 <Decode_Hexa+0x181>
mov    %rbx,0x8(%rsp)
cmp    %r15,%rbx
mov    0x4(%rsp),%ecx
jb     136a <Decode_Hexa+0x1ea>
cmpb   $0x2f,(%rbx)
jne    136a <Decode_Hexa+0x1ea>
mov    %r12d,(%r14)
movb   $0x0,(%rbx)
add    $0x1,%rbx
lea    0x8(%rsp),%rsi
mov    %rbx,%rdi
mov    $0xa,%edx
call   1060 <strtol@plt>
mov    0x50(%rsp),%rcx
mov    %eax,(%rcx)
mov    %r15,%rax
movzbl 0x1(%rax),%ecx
mov    %cl,(%rax)
add    $0x1,%rax
test   %cl,%cl
jne    1353 <Decode_Hexa+0x1d3>
mov    %rax,0x8(%rsp)
mov    0x4(%rsp),%ecx
test   %ecx,%ecx
je     13b0 <Decode_Hexa+0x230>
mov    %r15,%rdi
call   1040 <Quote_If_Needed@plt>
jmp    13b0 <Decode_Hexa+0x230>
call   1080 <Decode_String@plt>
mov    %rax,%rbp
test   %rax,%rax
mov    0x4(%rsp),%eax
je     13ae <Decode_Hexa+0x22e>
cmpb   $0x5f,0x0(%rbp)
jne    13ae <Decode_Hexa+0x22e>
cmpb   $0x5f,0x1(%rbp)
jne    13ae <Decode_Hexa+0x22e>
add    $0x2,%rbp
test   %eax,%eax
je     11d5 <Decode_Hexa+0x55>
mov    %rbx,%rdi
call   1040 <Quote_If_Needed@plt>
jmp    11d5 <Decode_Hexa+0x55>
xor    %ebp,%ebp
mov    %rbp,%rax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
cmpb   $0x5f,0x0(%rbp)
mov    0x4(%rsp),%ecx
jne    129b <Decode_Hexa+0x11b>
jmp    128b <Decode_Hexa+0x10b>

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

LLVM IR (-O2):
@.str = [6 x i8] c"_$aux\00"
define i8* @Decode_Hexa(i8* %0, i32 %1, i32 %2, i32 %3, i8* %4, i8* %5, i32* nocapture %6, i32* nocapture writeonly %7) {
%9 = alloca i8*
%10 = alloca i8*
%11 = bitcast i8** %9 to i8*
%12 = bitcast i8** %10 to i8*
%13 = load i8, i8* %0
%14 = icmp eq i8 %13, 88
br i1 %14, label %15, label %135
15: ; preds = %8
%16 = getelementptr inbounds i8, i8* %0, i64 1
%17 = load i8, i8* %16
%18 = sext i8 %17 to i32
%19 = add i8 %17, -53
%20 = icmp ult i8 %19, -5
br i1 %20, label %135, label %21
21: ; preds = %15
%22 = getelementptr inbounds i8, i8* %0, i64 2
%23 = add nsw i32 %18, -48
%24 = and i32 %18, 1
%25 = getelementptr inbounds i8, i8* %0, i64 3
%26 = load i8, i8* %22
%27 = icmp eq i8 %26, 95
br i1 %27, label %28, label %135
28: ; preds = %21
%29 = icmp ult i32 %23, 2
br i1 %29, label %30, label %31
30: ; preds = %28
store i8 0, i8* %4
br label %53
31: ; preds = %28
%32 = and i32 %23, -2
%33 = icmp eq i32 %32, 2
br i1 %33, label %34, label %36
34: ; preds = %31
%35 = tail call i8* @Copy_Not_Encoded_String(i8* %25, i8* %4)
br label %38
36: ; preds = %31
%37 = tail call i8* @Decode_String(i8* %25, i8* %4)
br label %38
38: ; preds = %36, %34
%39 = phi i8* [ %35, %34 ], [ %37, %36 ]
%40 = icmp eq i8* %39, null
br i1 %40, label %135, label %41
41: ; preds = %38
%42 = load i8, i8* %39
%43 = icmp eq i8 %42, 95
br i1 %43, label %44, label %135
44: ; preds = %41
%45 = getelementptr inbounds i8, i8* %39, i64 1
%46 = getelementptr inbounds i8, i8* %39, i64 2
%47 = load i8, i8* %45
%48 = icmp eq i8 %47, 95
br i1 %48, label %49, label %135
49: ; preds = %44
%50 = icmp eq i32 %2, 0
br i1 %50, label %53, label %51
51: ; preds = %49
%52 = tail call i32 @Quote_If_Needed(i8* %4)
br label %53
53: ; preds = %49, %51, %30
%54 = phi i8* [ %25, %30 ], [ %46, %51 ], [ %46, %49 ]
%55 = icmp eq i32 %24, 0
br i1 %55, label %56, label %58
56: ; preds = %53
%57 = tail call i8* @Copy_Not_Encoded_String(i8* %54, i8* %5)
br label %60
58: ; preds = %53
%59 = tail call i8* @Decode_String(i8* %54, i8* %5)
br label %60
60: ; preds = %58, %56
%61 = phi i8* [ %57, %56 ], [ %59, %58 ]
%62 = icmp eq i8* %61, null
br i1 %62, label %135, label %63
63: ; preds = %60
%64 = load i8, i8* %5
%65 = icmp eq i8 %64, 0
br i1 %65, label %135, label %66
66: ; preds = %63
store i32 -1, i32* %6
%67 = load i8, i8* %61
%68 = icmp eq i8 %67, 95
br i1 %68, label %69, label %91
69: ; preds = %66
%70 = getelementptr inbounds i8, i8* %61, i64 1
%71 = load i8, i8* %70
%72 = icmp eq i8 %71, 95
br i1 %72, label %73, label %91
73: ; preds = %69
%74 = getelementptr inbounds i8, i8* %61, i64 2
%75 = load i8, i8* %74
%76 = icmp eq i8 %75, 97
br i1 %76, label %77, label %91
77: ; preds = %73
%78 = getelementptr inbounds i8, i8* %61, i64 3
%79 = call i32 @strtoul(i8* %78, i8** %9, i32 10)
%80 = load i8*, i8** %9
%81 = icmp eq i8* %80, %78
%82 = select i1 %81, i32 -1, i32 %79
store i32 %82, i32* %6
%83 = icmp ugt i32 %82, 1024
br i1 %83, label %91, label %84
84: ; preds = %77
%85 = load i8, i8* %80
%86 = tail call i64 @isalnum(i8 signext %85)
%87 = icmp eq i64 %86, 0
br i1 %87, label %88, label %91
88: ; preds = %84
%89 = load i8, i8* %80
%90 = icmp eq i8 %89, 95
br i1 %90, label %91, label %95
91: ; preds = %66, %69, %73, %88, %84, %77
%92 = phi i8* [ %80, %88 ], [ %80, %84 ], [ %80, %77 ], [ %61, %73 ], [ %61, %69 ], [ %61, %66 ]
%93 = icmp eq i32 %1, 0
br i1 %93, label %94, label %135
94: ; preds = %91
store i32 -1, i32* %6
br label %95
95: ; preds = %94, %88
%96 = phi i8* [ %92, %94 ], [ %80, %88 ]
store i32 -1, i32* %7
%97 = icmp eq i32 %3, 0
br i1 %97, label %131, label %98
98: ; preds = %95
%99 = load i8, i8* %5
%100 = icmp eq i8 %99, 36
br i1 %100, label %101, label %131
101: ; preds = %98
%102 = tail call i8* @strstr(i8* %5, i8* dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0))
%103 = icmp eq i8* %102, null
br i1 %103, label %131, label %104
104: ; preds = %101
%105 = getelementptr inbounds i8, i8* %102, i64 5
%106 = call i32 @strtol(i8* %105, i8** %10, i32 10)
%107 = load i8*, i8** %10
%108 = load i8, i8* %107
%109 = icmp eq i8 %108, 0
br i1 %109, label %110, label %131
110: ; preds = %104, %114
%111 = phi i8* [ %112, %114 ], [ %102, %104 ]
%112 = getelementptr inbounds i8, i8* %111, i64 -1
%113 = icmp ugt i8* %112, %5
br i1 %113, label %114, label %118
114: ; preds = %110
%115 = load i8, i8* %112
%116 = tail call i64 @isdigit(i8 signext %115)
%117 = icmp eq i64 %116, 0
br i1 %117, label %118, label %110
118: ; preds = %110, %114
store i8* %112, i8** %9
%119 = icmp ult i8* %112, %5
br i1 %119, label %131, label %120
120: ; preds = %118
%121 = load i8, i8* %112
%122 = icmp eq i8 %121, 47
br i1 %122, label %123, label %131
123: ; preds = %120
store i32 %106, i32* %7
store i8 0, i8* %112
%124 = call i32 @strtol(i8* %111, i8** %9, i32 10)
store i32 %124, i32* %6
br label %125
125: ; preds = %125, %123
%126 = phi i8* [ %127, %125 ], [ %5, %123 ]
%127 = getelementptr inbounds i8, i8* %126, i64 1
%128 = load i8, i8* %127
store i8 %128, i8* %126
%129 = icmp eq i8 %128, 0
br i1 %129, label %130, label %125
130: ; preds = %125
store i8* %127, i8** %9
br label %131
131: ; preds = %130, %104, %120, %118, %101, %98, %95
%132 = icmp eq i32 %2, 0
br i1 %132, label %135, label %133
133: ; preds = %131
%134 = tail call i32 @Quote_If_Needed(i8* %5)
br label %135
135: ; preds = %131, %133, %91, %60, %63, %38, %41, %44, %21, %8, %15
%136 = phi i8* [ null, %15 ], [ null, %8 ], [ null, %21 ], [ null, %44 ], [ null, %41 ], [ null, %38 ], [ null, %63 ], [ null, %60 ], [ null, %91 ], [ %96, %133 ], [ %96, %131 ]
ret i8* %136
}