#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*/ isdigit(unsigned char);
int /*<<< orphan*/ isxdigit(unsigned char);
int /*<<< orphan*/ toupper(unsigned char);
char *unescape(char *orig) {
  char c, *cp, *new = orig;
  int i;
  for (cp = orig; (*orig = *cp); cp++, orig++) {
    if (*cp != '\\')
      continue;
    switch (*++cp) {
    case 'a':
      *orig = '\a';
      continue;
    case 'b':
      *orig = '\b';
      continue;
    case 'e':
      *orig = '\e';
      continue;
    case 'f':
      *orig = '\f';
      continue;
    case 'n':
      *orig = '\n';
      continue;
    case 'r':
      *orig = '\r';
      continue;
    case 't':
      *orig = '\t';
      continue;
    case 'v':
      *orig = '\v';
      continue;
    case '\\':
      *orig = '\\';
      continue;
    case '\'':
      *orig = '\'';
      continue;
    case '\"':
      *orig = '"';
      continue;
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
      for (i = 0, c = 0; ((int)((unsigned char)*cp) >= '0' &&
                          (int)((unsigned char)*cp) <= '7') &&
                         i < 3;
           i++, cp++) {
        c <<= 3;
        c |= (*cp - '0');
      }
      *orig = c;
      --cp;
      continue;
    case 'x':
      cp++;
      for (i = 0, c = 0; isxdigit((unsigned char)*cp) && i < 2; i++, cp++) {
        c <<= 4;
        if (isdigit((unsigned char)*cp))
          c |= (*cp - '0');
        else
          c |= ((toupper((unsigned char)*cp) - 'A') + 10);
      }
      *orig = c;
      --cp;
      continue;
    default:
      --cp;
      break;
    }
  }
  return (new);
}


x86 assembly (clang, -O0):
<unescape>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%al
mov    -0x8(%rbp),%rcx
mov    %al,(%rcx)
cmp    $0x0,%al
je     13da <unescape+0x2aa>
mov    -0x18(%rbp),%rax
movsbl (%rax),%eax
cmp    $0x5c,%eax
je     1175 <unescape+0x45>
jmp    13bd <unescape+0x28d>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
movsbl 0x1(%rax),%eax
add    $0xffffffde,%eax
mov    %eax,%ecx
mov    %rcx,-0x30(%rbp)
sub    $0x56,%eax
ja     13ac <unescape+0x27c>
mov    -0x30(%rbp),%rax
lea    0xe5b(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x8(%rbp),%rax
movb   $0x7,(%rax)
jmp    13bd <unescape+0x28d>
mov    -0x8(%rbp),%rax
movb   $0x8,(%rax)
jmp    13bd <unescape+0x28d>
mov    -0x8(%rbp),%rax
movb   $0x1b,(%rax)
jmp    13bd <unescape+0x28d>
mov    -0x8(%rbp),%rax
movb   $0xc,(%rax)
jmp    13bd <unescape+0x28d>
mov    -0x8(%rbp),%rax
movb   $0xa,(%rax)
jmp    13bd <unescape+0x28d>
mov    -0x8(%rbp),%rax
movb   $0xd,(%rax)
jmp    13bd <unescape+0x28d>
mov    -0x8(%rbp),%rax
movb   $0x9,(%rax)
jmp    13bd <unescape+0x28d>
mov    -0x8(%rbp),%rax
movb   $0xb,(%rax)
jmp    13bd <unescape+0x28d>
mov    -0x8(%rbp),%rax
movb   $0x5c,(%rax)
jmp    13bd <unescape+0x28d>
mov    -0x8(%rbp),%rax
movb   $0x27,(%rax)
jmp    13bd <unescape+0x28d>
mov    -0x8(%rbp),%rax
movb   $0x22,(%rax)
jmp    13bd <unescape+0x28d>
movl   $0x0,-0x24(%rbp)
movb   $0x0,-0x9(%rbp)
mov    -0x18(%rbp),%rax
movzbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x30,%ecx
mov    %al,-0x31(%rbp)
jl     1271 <unescape+0x141>
mov    -0x18(%rbp),%rax
movzbl (%rax),%ecx
xor    %eax,%eax
cmp    $0x37,%ecx
mov    %al,-0x31(%rbp)
jg     1271 <unescape+0x141>
cmpl   $0x3,-0x24(%rbp)
setl   %al
mov    %al,-0x31(%rbp)
mov    -0x31(%rbp),%al
test   $0x1,%al
jne    1281 <unescape+0x151>
jmp    12b8 <unescape+0x188>
movsbl -0x9(%rbp),%eax
shl    $0x3,%eax
mov    %al,-0x9(%rbp)
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
sub    $0x30,%ecx
movsbl -0x9(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x9(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    123d <unescape+0x10d>
mov    -0x9(%rbp),%cl
mov    -0x8(%rbp),%rax
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
jmp    13bd <unescape+0x28d>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
movl   $0x0,-0x24(%rbp)
movb   $0x0,-0x9(%rbp)
mov    -0x18(%rbp),%rax
movzbl (%rax),%edi
call   1050 <isxdigit@plt>
mov    %eax,%ecx
xor    %eax,%eax
cmp    $0x0,%ecx
mov    %al,-0x32(%rbp)
je     130f <unescape+0x1df>
cmpl   $0x2,-0x24(%rbp)
setl   %al
mov    %al,-0x32(%rbp)
mov    -0x32(%rbp),%al
test   $0x1,%al
jne    131f <unescape+0x1ef>
jmp    1392 <unescape+0x262>
movsbl -0x9(%rbp),%eax
shl    $0x4,%eax
mov    %al,-0x9(%rbp)
mov    -0x18(%rbp),%rax
movzbl (%rax),%edi
call   1030 <isdigit@plt>
cmp    $0x0,%eax
je     1356 <unescape+0x226>
mov    -0x18(%rbp),%rax
movsbl (%rax),%ecx
sub    $0x30,%ecx
movsbl -0x9(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x9(%rbp)
jmp    1373 <unescape+0x243>
mov    -0x18(%rbp),%rax
movzbl (%rax),%edi
call   1040 <toupper@plt>
mov    %eax,%ecx
sub    $0x41,%ecx
add    $0xa,%ecx
movsbl -0x9(%rbp),%eax
or     %ecx,%eax
mov    %al,-0x9(%rbp)
jmp    1378 <unescape+0x248>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
jmp    12e9 <unescape+0x1b9>
mov    -0x9(%rbp),%cl
mov    -0x8(%rbp),%rax
mov    %cl,(%rax)
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
jmp    13bd <unescape+0x28d>
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
jmp    13bd <unescape+0x28d>
mov    -0x18(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x18(%rbp)
mov    -0x8(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x8(%rbp)
jmp    114c <unescape+0x1c>
mov    -0x20(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<unescape>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdi,%r14
mov    (%rdi),%al
test   %al,%al
je     12cf <unescape+0x19f>
lea    0xeb1(%rip),%r12
mov    %r14,%rbp
mov    %r14,%rbx
cmp    $0x5c,%al
jne    12c0 <unescape+0x190>
jmp    1173 <unescape+0x43>
nop
add    $0x1,%rbx
add    $0x1,%rbp
movzbl (%rbx),%eax
cmp    $0x5c,%al
jne    12c0 <unescape+0x190>
movsbl 0x1(%rbx),%edx
lea    -0x22(%rdx),%ecx
cmp    $0x56,%ecx
ja     12c0 <unescape+0x190>
lea    0x1(%rbx),%rax
movslq (%r12,%rcx,4),%rcx
add    %r12,%rcx
jmp    *%rcx
xor    %ecx,%ecx
cmp    $0x30,%dl
jb     11de <unescape+0xae>
cmp    $0x37,%dl
ja     11de <unescape+0xae>
add    $0xd0,%dl
lea    0x2(%rbx),%rax
mov    0x2(%rbx),%cl
cmp    $0x30,%cl
jb     11dc <unescape+0xac>
cmp    $0x37,%cl
ja     11dc <unescape+0xac>
shl    $0x3,%dl
add    $0xd0,%cl
or     %dl,%cl
lea    0x3(%rbx),%rax
mov    0x3(%rbx),%dl
cmp    $0x30,%dl
jb     11de <unescape+0xae>
cmp    $0x37,%dl
ja     11de <unescape+0xae>
shl    $0x3,%cl
add    $0xd0,%dl
or     %cl,%dl
add    $0x4,%rbx
mov    %edx,%ecx
mov    %rbx,%rax
jmp    11de <unescape+0xae>
mov    %edx,%ecx
mov    %cl,0x0(%rbp)
add    $0xffffffffffffffff,%rax
mov    %rax,%rbx
jmp    12c0 <unescape+0x190>
movb   $0x22,0x0(%rbp)
jmp    11e5 <unescape+0xb5>
movb   $0x27,0x0(%rbp)
jmp    11e5 <unescape+0xb5>
movb   $0x5c,0x0(%rbp)
jmp    11e5 <unescape+0xb5>
movb   $0x7,0x0(%rbp)
jmp    11e5 <unescape+0xb5>
movb   $0x8,0x0(%rbp)
jmp    11e5 <unescape+0xb5>
movb   $0x1b,0x0(%rbp)
jmp    11e5 <unescape+0xb5>
movb   $0xc,0x0(%rbp)
jmp    11e5 <unescape+0xb5>
movb   $0xa,0x0(%rbp)
jmp    11e5 <unescape+0xb5>
movb   $0xd,0x0(%rbp)
jmp    11e5 <unescape+0xb5>
movb   $0x9,0x0(%rbp)
jmp    11e5 <unescape+0xb5>
movb   $0xb,0x0(%rbp)
jmp    11e5 <unescape+0xb5>
lea    0x2(%rbx),%r13
movzbl 0x2(%rbx),%edi
call   1050 <isxdigit@plt>
test   %eax,%eax
je     1258 <unescape+0x128>
movzbl 0x0(%r13),%edi
call   1030 <isdigit@plt>
mov    0x0(%r13),%r15b
test   %eax,%eax
je     125d <unescape+0x12d>
add    $0xd0,%r15b
jmp    126d <unescape+0x13d>
xor    %r15d,%r15d
jmp    12b3 <unescape+0x183>
movzbl %r15b,%edi
call   1040 <toupper@plt>
mov    %eax,%r15d
add    $0xc9,%r15b
movzbl 0x3(%rbx),%edi
add    $0x3,%rbx
call   1050 <isxdigit@plt>
test   %eax,%eax
je     12b0 <unescape+0x180>
shl    $0x4,%r15b
movzbl (%rbx),%edi
call   1030 <isdigit@plt>
mov    %eax,%ecx
mov    (%rbx),%al
test   %ecx,%ecx
je     1296 <unescape+0x166>
add    $0xd0,%al
jmp    12a0 <unescape+0x170>
movzbl %al,%edi
call   1040 <toupper@plt>
add    $0xc9,%al
or     %al,%r15b
movzbl 0x1(%rbx),%edi
add    $0x1,%rbx
call   1050 <isxdigit@plt>
mov    %rbx,%r13
mov    %r15b,0x0(%rbp)
add    $0xffffffffffffffff,%r13
mov    %r13,%rbx
xchg   %ax,%ax
movzbl 0x1(%rbx),%eax
mov    %al,0x1(%rbp)
test   %al,%al
jne    1160 <unescape+0x30>
mov    %r14,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define i8* @unescape(i8* returned %0) {
%2 = load i8, i8* %0
%3 = icmp eq i8 %2, 0
br i1 %3, label %105, label %4
4: ; preds = %1, %103
%5 = phi i8 [ %104, %103 ], [ %2, %1 ]
%6 = phi i8* [ %100, %103 ], [ %0, %1 ]
%7 = phi i8* [ %99, %103 ], [ %0, %1 ]
%8 = icmp eq i8 %5, 92
br i1 %8, label %9, label %97
9: ; preds = %4
%10 = getelementptr inbounds i8, i8* %7, i64 1
%11 = load i8, i8* %10
%12 = sext i8 %11 to i32
switch i32 %12, label %97 [
i32 97, label %13
i32 98, label %14
i32 101, label %15
i32 102, label %16
i32 110, label %17
i32 114, label %18
i32 116, label %19
i32 118, label %20
i32 92, label %21
i32 39, label %22
i32 34, label %23
i32 48, label %24
i32 49, label %24
i32 50, label %24
i32 51, label %24
i32 52, label %24
i32 53, label %24
i32 54, label %24
i32 55, label %24
i32 120, label %53
]
13: ; preds = %9
store i8 7, i8* %6
br label %97
14: ; preds = %9
store i8 8, i8* %6
br label %97
15: ; preds = %9
store i8 27, i8* %6
br label %97
16: ; preds = %9
store i8 12, i8* %6
br label %97
17: ; preds = %9
store i8 10, i8* %6
br label %97
18: ; preds = %9
store i8 13, i8* %6
br label %97
19: ; preds = %9
store i8 9, i8* %6
br label %97
20: ; preds = %9
store i8 11, i8* %6
br label %97
21: ; preds = %9
store i8 92, i8* %6
br label %97
22: ; preds = %9
store i8 39, i8* %6
br label %97
23: ; preds = %9
store i8 34, i8* %6
br label %97
24: ; preds = %9, %9, %9, %9, %9, %9, %9, %9
%25 = icmp ugt i8 %11, 47
%26 = icmp ult i8 %11, 56
%27 = and i1 %25, %26
br i1 %27, label %28, label %49
28: ; preds = %24
%29 = add nsw i8 %11, -48
%30 = getelementptr inbounds i8, i8* %7, i64 2
%31 = load i8, i8* %30
%32 = icmp ugt i8 %31, 47
%33 = icmp ult i8 %31, 56
%34 = and i1 %32, %33
br i1 %34, label %35, label %49
35: ; preds = %28
%36 = shl i8 %29, 3
%37 = add nsw i8 %31, -48
%38 = or i8 %37, %36
%39 = getelementptr inbounds i8, i8* %7, i64 3
%40 = load i8, i8* %39
%41 = icmp ugt i8 %40, 47
%42 = icmp ult i8 %40, 56
%43 = and i1 %41, %42
br i1 %43, label %44, label %49
44: ; preds = %35
%45 = shl i8 %38, 3
%46 = add nsw i8 %40, -48
%47 = or i8 %46, %45
%48 = getelementptr inbounds i8, i8* %7, i64 4
br label %49
49: ; preds = %44, %28, %35, %24
%50 = phi i8 [ 0, %24 ], [ %29, %28 ], [ %38, %35 ], [ %47, %44 ]
%51 = phi i8* [ %10, %24 ], [ %30, %28 ], [ %39, %35 ], [ %48, %44 ]
store i8 %50, i8* %6
%52 = getelementptr inbounds i8, i8* %51, i64 -1
br label %97
53: ; preds = %9
%54 = getelementptr inbounds i8, i8* %7, i64 2
%55 = load i8, i8* %54
%56 = tail call i32 @isxdigit(i8 zeroext %55)
%57 = icmp eq i32 %56, 0
br i1 %57, label %93, label %58
58: ; preds = %53
%59 = load i8, i8* %54
%60 = tail call i32 @isdigit(i8 zeroext %59)
%61 = icmp eq i32 %60, 0
%62 = load i8, i8* %54
br i1 %61, label %65, label %63
63: ; preds = %58
%64 = add i8 %62, -48
br label %69
65: ; preds = %58
%66 = tail call i32 @toupper(i8 zeroext %62)
%67 = trunc i32 %66 to i8
%68 = add i8 %67, -55
br label %69
69: ; preds = %65, %63
%70 = phi i8 [ %64, %63 ], [ %68, %65 ]
%71 = getelementptr inbounds i8, i8* %7, i64 3
%72 = load i8, i8* %71
%73 = tail call i32 @isxdigit(i8 zeroext %72)
%74 = icmp eq i32 %73, 0
br i1 %74, label %93, label %75
75: ; preds = %69
%76 = shl i8 %70, 4
%77 = load i8, i8* %71
%78 = tail call i32 @isdigit(i8 zeroext %77)
%79 = icmp eq i32 %78, 0
%80 = load i8, i8* %71
br i1 %79, label %83, label %81
81: ; preds = %75
%82 = add i8 %80, -48
br label %87
83: ; preds = %75
%84 = tail call i32 @toupper(i8 zeroext %80)
%85 = trunc i32 %84 to i8
%86 = add i8 %85, -55
br label %87
87: ; preds = %81, %83
%88 = phi i8 [ %82, %81 ], [ %86, %83 ]
%89 = or i8 %88, %76
%90 = getelementptr inbounds i8, i8* %71, i64 1
%91 = load i8, i8* %90
%92 = tail call i32 @isxdigit(i8 zeroext %91)
br label %93
93: ; preds = %69, %87, %53
%94 = phi i8 [ 0, %53 ], [ %70, %69 ], [ %89, %87 ]
%95 = phi i8* [ %54, %53 ], [ %71, %69 ], [ %90, %87 ]
store i8 %94, i8* %6
%96 = getelementptr inbounds i8, i8* %95, i64 -1
br label %97
97: ; preds = %9, %4, %93, %49, %23, %22, %21, %20, %19, %18, %17, %16, %15, %14, %13
%98 = phi i8* [ %7, %4 ], [ %96, %93 ], [ %52, %49 ], [ %10, %23 ], [ %10, %22 ], [ %10, %21 ], [ %10, %20 ], [ %10, %19 ], [ %10, %18 ], [ %10, %17 ], [ %10, %16 ], [ %10, %15 ], [ %10, %14 ], [ %10, %13 ], [ %7, %9 ]
%99 = getelementptr inbounds i8, i8* %98, i64 1
%100 = getelementptr inbounds i8, i8* %6, i64 1
%101 = load i8, i8* %99
store i8 %101, i8* %100
%102 = icmp eq i8 %101, 0
br i1 %102, label %105, label %103
103: ; preds = %97
%104 = load i8, i8* %99
br label %4
105: ; preds = %97, %1
ret i8* %0
}