#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 */
scalar_t__ checkSym(char);
char decHex(int);
int /*<<< orphan*/ printf(char *, char *);
void findPal(int num) {
  int i, l, orignum = num, len, pal = 1;
  char temphex[17], hex[17];
  for (i = 0; num != 0; i++) {
    temphex[i] = decHex(num % 16);
    num /= 16;
  }
  len = i;
  for (l = 0; i > 0; l++, i--) {
    hex[l] = temphex[i - 1];
  }
  for (i = 0; i < 17; i++) {
    if (checkSym(hex[i])) {
      hex[i] = 0;
    }
  }
  if (len == 1) {
    printf("%s", hex);
    return;
  } else if (len == 2) {
    if (hex[0] == hex[1]) {
      printf("%s", hex);
      return;
    } else {
      findPal(orignum + 1);
      return;
    }
  } else {
    for (i = 0, l--; i < len / 2; i++, l--) {
      if (hex[i] != hex[l]) {
        pal = 0;
      }
    }
  }
  if (pal == 1) {
    printf("%s", hex);
    return;
  }
  findPal(orignum + 1);
  return;
}


x86 assembly (clang, -O0):
<findPal>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %edi,-0x4(%rbp)
mov    -0x4(%rbp),%eax
mov    %eax,-0x10(%rbp)
movl   $0x1,-0x18(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x0,-0x4(%rbp)
je     11a1 <findPal+0x61>
mov    -0x4(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    %edx,%edi
call   1030 <decHex@plt>
mov    %al,%cl
movslq -0x8(%rbp),%rax
mov    %cl,-0x30(%rbp,%rax,1)
mov    -0x4(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    %eax,-0x4(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    115f <findPal+0x1f>
mov    -0x8(%rbp),%eax
mov    %eax,-0x14(%rbp)
movl   $0x0,-0xc(%rbp)
cmpl   $0x0,-0x8(%rbp)
jle    11e3 <findPal+0xa3>
mov    -0x8(%rbp),%eax
sub    $0x1,%eax
cltq
mov    -0x30(%rbp,%rax,1),%cl
movslq -0xc(%rbp),%rax
mov    %cl,-0x50(%rbp,%rax,1)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xc(%rbp)
mov    -0x8(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x8(%rbp)
jmp    11ae <findPal+0x6e>
movl   $0x0,-0x8(%rbp)
cmpl   $0x11,-0x8(%rbp)
jge    1228 <findPal+0xe8>
movslq -0x8(%rbp),%rax
movsbl -0x50(%rbp,%rax,1),%edi
call   1050 <checkSym@plt>
cmp    $0x0,%rax
je     1215 <findPal+0xd5>
movslq -0x8(%rbp),%rax
movb   $0x0,-0x50(%rbp,%rax,1)
jmp    121a <findPal+0xda>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    11ea <findPal+0xaa>
cmpl   $0x1,-0x14(%rbp)
jne    1247 <findPal+0x107>
lea    -0x50(%rbp),%rsi
lea    0xdc3(%rip),%rdi
call   1040 <printf@plt>
jmp    1325 <findPal+0x1e5>
cmpl   $0x2,-0x14(%rbp)
jne    1286 <findPal+0x146>
movsbl -0x50(%rbp),%eax
movsbl -0x4f(%rbp),%ecx
cmp    %ecx,%eax
jne    1276 <findPal+0x136>
lea    -0x50(%rbp),%rsi
lea    0xd94(%rip),%rdi
call   1040 <printf@plt>
jmp    1325 <findPal+0x1e5>
mov    -0x10(%rbp),%edi
add    $0x1,%edi
call   1060 <findPal@plt>
jmp    1325 <findPal+0x1e5>
movl   $0x0,-0x8(%rbp)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
mov    -0x8(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x54(%rbp),%eax
cmp    %ecx,%eax
jge    12f1 <findPal+0x1b1>
movslq -0x8(%rbp),%rax
movsbl -0x50(%rbp,%rax,1),%eax
movslq -0xc(%rbp),%rcx
movsbl -0x50(%rbp,%rcx,1),%ecx
cmp    %ecx,%eax
je     12d5 <findPal+0x195>
movl   $0x0,-0x18(%rbp)
jmp    12da <findPal+0x19a>
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
jmp    1296 <findPal+0x156>
jmp    12f6 <findPal+0x1b6>
jmp    12fb <findPal+0x1bb>
cmpl   $0x1,-0x18(%rbp)
jne    131a <findPal+0x1da>
lea    -0x50(%rbp),%rsi
lea    0xcf0(%rip),%rdi
call   1040 <printf@plt>
jmp    1325 <findPal+0x1e5>
mov    -0x10(%rbp),%edi
add    $0x1,%edi
call   1060 <findPal@plt>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<findPal>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x40,%rsp
mov    %edi,%r14d
xor    %r12d,%r12d
test   %edi,%edi
je     1243 <findPal+0x103>
mov    %r14d,%edi
nopl   (%rax)
lea    0xf(%rdi),%ebp
test   %edi,%edi
mov    %edi,%ebx
cmovs  %ebp,%ebx
mov    %ebx,%eax
and    $0xfffffff0,%eax
sub    %eax,%edi
call   1030 <decHex@plt>
mov    %al,0x20(%rsp,%r12,1)
sar    $0x4,%ebx
add    $0x1,%r12
mov    %ebx,%edi
cmp    $0x1f,%ebp
jae    1160 <findPal+0x20>
test   %r12d,%r12d
jle    1243 <findPal+0x103>
mov    %r12d,%r8d
cmp    $0x8,%r8
jae    12af <findPal+0x16f>
xor    %eax,%eax
mov    %r8,%rcx
mov    %r12d,%edx
sub    %eax,%edx
mov    %rax,%rsi
not    %rsi
add    %rsi,%r8
test   $0x3,%dl
je     11e8 <findPal+0xa8>
mov    %r12d,%edx
sub    %al,%dl
movzbl %dl,%esi
and    $0x3,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0xffffffffffffffff,%rcx
mov    %ecx,%edx
movzbl 0x20(%rsp,%rdx,1),%edx
mov    %dl,(%rsp,%rax,1)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    11d0 <findPal+0x90>
cmp    $0x3,%r8
jb     123e <findPal+0xfe>
mov    $0xfffffffe,%edx
mov    %r12d,%esi
cs nopw 0x0(%rax,%rax,1)
lea    (%rcx,%rdx,1),%rdi
lea    0x1(%rdi),%ebp
movzbl 0x20(%rsp,%rbp,1),%ebx
mov    %bl,(%rsp,%rax,1)
mov    %edi,%ebp
movzbl 0x20(%rsp,%rbp,1),%ebx
mov    %bl,0x1(%rsp,%rax,1)
add    $0xffffffff,%edi
movzbl 0x20(%rsp,%rdi,1),%ebx
mov    %bl,0x2(%rsp,%rax,1)
add    $0xfffffffffffffffc,%rcx
mov    %ecx,%edi
movzbl 0x20(%rsp,%rdi,1),%ebx
mov    %bl,0x3(%rsp,%rax,1)
add    $0x4,%rax
cmp    %rax,%rsi
jne    1200 <findPal+0xc0>
mov    %r12d,%r15d
jmp    1246 <findPal+0x106>
xor    %r15d,%r15d
xor    %ebp,%ebp
jmp    125a <findPal+0x11a>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rbp
cmp    $0x11,%rbp
je     126e <findPal+0x12e>
movsbl (%rsp,%rbp,1),%edi
call   1050 <checkSym@plt>
test   %rax,%rax
je     1250 <findPal+0x110>
movb   $0x0,(%rsp,%rbp,1)
jmp    1250 <findPal+0x110>
cmp    $0x1,%r12d
je     13db <findPal+0x29b>
cmp    $0x2,%r12d
jne    1290 <findPal+0x150>
mov    (%rsp),%al
cmp    0x1(%rsp),%al
jne    13f7 <findPal+0x2b7>
jmp    13db <findPal+0x29b>
jb     13db <findPal+0x29b>
mov    %r12d,%edx
shr    %edx
xor    %eax,%eax
cmp    $0x10,%r12d
jae    12e0 <findPal+0x1a0>
mov    $0x1,%esi
xor    %ecx,%ecx
jmp    13a2 <findPal+0x262>
lea    -0x1(%r8),%rcx
lea    -0x1(%r12),%esi
xor    %eax,%eax
cmp    %ecx,%esi
jb     11a1 <findPal+0x61>
shr    $0x20,%rcx
mov    %r8,%rcx
jne    11a4 <findPal+0x64>
cmp    $0x20,%r8d
jae    140f <findPal+0x2cf>
xor    %eax,%eax
jmp    14c8 <findPal+0x388>
mov    %edx,%ecx
and    $0xfffffff8,%ecx
mov    %rsp,%rsi
add    %r15,%rsi
add    $0xfffffffffffffffc,%rsi
sub    %rcx,%r15
movdqa 0xd06(%rip),%xmm0
xor    %edi,%edi
movdqa %xmm0,%xmm1
movq   (%rsp,%rdi,1),%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
movd   0x4(%rsp,%rdi,1),%xmm3
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
movd   (%rsi),%xmm4
punpcklbw %xmm4,%xmm4
movd   -0x4(%rsi),%xmm5
punpcklbw %xmm5,%xmm5
pshufd $0xc4,%xmm4,%xmm4
pshuflw $0xac,%xmm4,%xmm4
pshufhw $0x24,%xmm4,%xmm4
pcmpeqb %xmm2,%xmm4
psrad  $0x18,%xmm4
pand   %xmm4,%xmm0
pshufd $0xc4,%xmm5,%xmm2
pshuflw $0xac,%xmm2,%xmm2
pshufhw $0x24,%xmm2,%xmm2
pcmpeqb %xmm3,%xmm2
psrad  $0x18,%xmm2
pand   %xmm2,%xmm1
add    $0x8,%rdi
add    $0xfffffffffffffff8,%rsi
cmp    %rdi,%rcx
jne    1300 <findPal+0x1c0>
movdqa 0xc87(%rip),%xmm2
movdqa %xmm0,%xmm3
pcmpeqd %xmm2,%xmm3
pand   %xmm3,%xmm1
pandn  %xmm0,%xmm3
por    %xmm1,%xmm3
pcmpeqd %xmm2,%xmm3
movmskps %xmm3,%edi
xor    %esi,%esi
cmp    $0xf,%edi
sete   %sil
cmp    %rdx,%rcx
je     13d6 <findPal+0x296>
lea    (%rsp,%rcx,1),%rdi
sub    %rdx,%rcx
mov    %rsp,%rdx
add    %r15,%rdx
add    $0xffffffffffffffff,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rdi),%ebx
cmp    (%rdx,%rbp,1),%bl
cmovne %eax,%esi
add    $0x1,%rdi
add    $0xffffffffffffffff,%rbp
cmp    %rbp,%rcx
jne    13c0 <findPal+0x280>
cmp    $0x1,%esi
jne    13f7 <findPal+0x2b7>
lea    0xc2e(%rip),%rdi
mov    %rsp,%rsi
call   1040 <printf@plt>
add    $0x40,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0x1,%r14d
mov    %r14d,%edi
add    $0x40,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
jmp    1060 <findPal@plt>
lea    -0x1(%r12),%rsi
mov    %r12d,%edi
mov    %r12d,%ecx
and    $0x1f,%ecx
mov    %r8,%rax
sub    %rcx,%rax
sub    %rcx,%rdi
xor    %ebp,%ebp
pxor   %xmm0,%xmm0
nopl   0x0(%rax)
mov    %esi,%edx
movdqu 0x1(%rsp,%rdx,1),%xmm1
movdqu 0x11(%rsp,%rdx,1),%xmm2
movdqa %xmm2,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm3,%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqa %xmm2,(%rsp,%rbp,1)
movdqa %xmm1,0x10(%rsp,%rbp,1)
add    $0x20,%rbp
add    $0xffffffffffffffe0,%rsi
cmp    %rbp,%rdi
jne    1430 <findPal+0x2f0>
test   %rcx,%rcx
je     123e <findPal+0xfe>
cmp    $0x8,%ecx
jb     11a4 <findPal+0x64>
mov    %rax,%rbp
mov    %r12d,%edi
mov    %r12d,%ecx
and    $0x7,%ecx
mov    %r8,%rax
sub    %rcx,%rax
mov    %rbp,%rsi
not    %rsi
add    %r12,%rsi
sub    %rcx,%rdi
pxor   %xmm0,%xmm0
nopw   0x0(%rax,%rax,1)
mov    %esi,%edx
movq   0x19(%rsp,%rdx,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,(%rsp,%rbp,1)
add    $0x8,%rbp
add    $0xfffffffffffffff8,%rsi
cmp    %rbp,%rdi
jne    14f0 <findPal+0x3b0>
test   %rcx,%rcx
jne    11a4 <findPal+0x64>
jmp    123e <findPal+0xfe>

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

LLVM IR (-O2):
@.str = [3 x i8] c"%s\00"
define void @findPal(i32 %0) {
%2 = alloca [17 x i8]
%3 = alloca [17 x i8]
%4 = getelementptr inbounds [17 x i8], [17 x i8]* %2, i64 0, i64 0
%5 = getelementptr inbounds [17 x i8], [17 x i8]* %3, i64 0, i64 0
%6 = icmp eq i32 %0, 0
br i1 %6, label %103, label %91
7: ; preds = %91
%8 = trunc i64 %98 to i32
%9 = icmp sgt i32 %8, 0
br i1 %9, label %10, label %103
10: ; preds = %7
%11 = and i64 %98, 4294967295
%12 = icmp ult i64 %11, 8
br i1 %12, label %67, label %13
13: ; preds = %10
%14 = add nsw i64 %11, -1
%15 = add i32 %8, -1
%16 = trunc i64 %14 to i32
%17 = icmp ult i32 %15, %16
%18 = icmp ugt i64 %14, 4294967295
%19 = or i1 %17, %18
br i1 %19, label %67, label %20
20: ; preds = %13
%21 = icmp ult i64 %11, 32
br i1 %21, label %48, label %22
22: ; preds = %20
%23 = and i64 %98, 31
%24 = sub nsw i64 %11, %23
br label %25
25: ; preds = %25, %22
%26 = phi i64 [ 0, %22 ], [ %42, %25 ]
%27 = sub i64 %92, %26
%28 = and i64 %27, 4294967295
%29 = getelementptr inbounds [17 x i8], [17 x i8]* %2, i64 0, i64 %28
%30 = getelementptr inbounds i8, i8* %29, i64 -15
%31 = bitcast i8* %30 to <16 x i8>*
%32 = load <16 x i8>, <16 x i8>* %31
%33 = shufflevector <16 x i8> %32, <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>
%34 = getelementptr inbounds i8, i8* %29, i64 -31
%35 = bitcast i8* %34 to <16 x i8>*
%36 = load <16 x i8>, <16 x i8>* %35
%37 = shufflevector <16 x i8> %36, <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>
%38 = getelementptr inbounds [17 x i8], [17 x i8]* %3, i64 0, i64 %26
%39 = bitcast i8* %38 to <16 x i8>*
store <16 x i8> %33, <16 x i8>* %39
%40 = getelementptr inbounds i8, i8* %38, i64 16
%41 = bitcast i8* %40 to <16 x i8>*
store <16 x i8> %37, <16 x i8>* %41
%42 = add nuw i64 %26, 32
%43 = icmp eq i64 %42, %24
br i1 %43, label %44, label %25
44: ; preds = %25
%45 = icmp eq i64 %23, 0
br i1 %45, label %101, label %46
46: ; preds = %44
%47 = icmp ult i64 %23, 8
br i1 %47, label %67, label %48
48: ; preds = %20, %46
%49 = phi i64 [ %24, %46 ], [ 0, %20 ]
%50 = and i64 %98, 7
%51 = sub nsw i64 %11, %50
br label %52
52: ; preds = %52, %48
%53 = phi i64 [ %49, %48 ], [ %63, %52 ]
%54 = sub i64 %92, %53
%55 = and i64 %54, 4294967295
%56 = getelementptr inbounds [17 x i8], [17 x i8]* %2, i64 0, i64 %55
%57 = getelementptr inbounds i8, i8* %56, i64 -7
%58 = bitcast i8* %57 to <8 x i8>*
%59 = load <8 x i8>, <8 x i8>* %58
%60 = shufflevector <8 x i8> %59, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%61 = getelementptr inbounds [17 x i8], [17 x i8]* %3, i64 0, i64 %53
%62 = bitcast i8* %61 to <8 x i8>*
store <8 x i8> %60, <8 x i8>* %62
%63 = add nuw i64 %53, 8
%64 = icmp eq i64 %63, %51
br i1 %64, label %65, label %52
65: ; preds = %52
%66 = icmp eq i64 %50, 0
br i1 %66, label %101, label %67
67: ; preds = %13, %10, %46, %65
%68 = phi i64 [ 0, %10 ], [ 0, %13 ], [ %24, %46 ], [ %51, %65 ]
%69 = phi i64 [ %11, %10 ], [ %11, %13 ], [ %23, %46 ], [ %50, %65 ]
%70 = sub i64 %98, %68
%71 = xor i64 %68, -1
%72 = add nsw i64 %11, %71
%73 = and i64 %70, 3
%74 = icmp eq i64 %73, 0
br i1 %74, label %87, label %75
75: ; preds = %67, %75
%76 = phi i64 [ %84, %75 ], [ %68, %67 ]
%77 = phi i64 [ %79, %75 ], [ %69, %67 ]
%78 = phi i64 [ %85, %75 ], [ 0, %67 ]
%79 = add nsw i64 %77, -1
%80 = and i64 %79, 4294967295
%81 = getelementptr inbounds [17 x i8], [17 x i8]* %2, i64 0, i64 %80
%82 = load i8, i8* %81
%83 = getelementptr inbounds [17 x i8], [17 x i8]* %3, i64 0, i64 %76
store i8 %82, i8* %83
%84 = add nuw nsw i64 %76, 1
%85 = add i64 %78, 1
%86 = icmp eq i64 %85, %73
br i1 %86, label %87, label %75
87: ; preds = %75, %67
%88 = phi i64 [ %68, %67 ], [ %84, %75 ]
%89 = phi i64 [ %69, %67 ], [ %79, %75 ]
%90 = icmp ult i64 %72, 3
br i1 %90, label %101, label %106
91: ; preds = %1, %91
%92 = phi i64 [ %98, %91 ], [ 0, %1 ]
%93 = phi i32 [ %97, %91 ], [ %0, %1 ]
%94 = srem i32 %93, 16
%95 = tail call signext i8 @decHex(i32 %94)
%96 = getelementptr inbounds [17 x i8], [17 x i8]* %2, i64 0, i64 %92
store i8 %95, i8* %96
%97 = sdiv i32 %93, 16
%98 = add nuw i64 %92, 1
%99 = add i32 %93, 15
%100 = icmp ult i32 %99, 31
br i1 %100, label %7, label %91
101: ; preds = %87, %106, %65, %44
%102 = and i64 %98, 4294967295
br label %103
103: ; preds = %101, %1, %7
%104 = phi i32 [ %8, %7 ], [ 0, %1 ], [ %8, %101 ]
%105 = phi i64 [ 0, %7 ], [ 0, %1 ], [ %102, %101 ]
br label %134
106: ; preds = %87, %106
%107 = phi i64 [ %132, %106 ], [ %88, %87 ]
%108 = phi i64 [ %127, %106 ], [ %89, %87 ]
%109 = add i64 %108, 4294967295
%110 = and i64 %109, 4294967295
%111 = getelementptr inbounds [17 x i8], [17 x i8]* %2, i64 0, i64 %110
%112 = load i8, i8* %111
%113 = getelementptr inbounds [17 x i8], [17 x i8]* %3, i64 0, i64 %107
store i8 %112, i8* %113
%114 = add nuw nsw i64 %107, 1
%115 = add i64 %108, 4294967294
%116 = and i64 %115, 4294967295
%117 = getelementptr inbounds [17 x i8], [17 x i8]* %2, i64 0, i64 %116
%118 = load i8, i8* %117
%119 = getelementptr inbounds [17 x i8], [17 x i8]* %3, i64 0, i64 %114
store i8 %118, i8* %119
%120 = add nuw nsw i64 %107, 2
%121 = add i64 %108, 4294967293
%122 = and i64 %121, 4294967295
%123 = getelementptr inbounds [17 x i8], [17 x i8]* %2, i64 0, i64 %122
%124 = load i8, i8* %123
%125 = getelementptr inbounds [17 x i8], [17 x i8]* %3, i64 0, i64 %120
store i8 %124, i8* %125
%126 = add nuw nsw i64 %107, 3
%127 = add nsw i64 %108, -4
%128 = and i64 %127, 4294967295
%129 = getelementptr inbounds [17 x i8], [17 x i8]* %2, i64 0, i64 %128
%130 = load i8, i8* %129
%131 = getelementptr inbounds [17 x i8], [17 x i8]* %3, i64 0, i64 %126
store i8 %130, i8* %131
%132 = add nuw nsw i64 %107, 4
%133 = icmp eq i64 %132, %11
br i1 %133, label %101, label %106
134: ; preds = %103, %141
%135 = phi i64 [ 0, %103 ], [ %142, %141 ]
%136 = getelementptr inbounds [17 x i8], [17 x i8]* %3, i64 0, i64 %135
%137 = load i8, i8* %136
%138 = tail call i64 @checkSym(i8 signext %137)
%139 = icmp eq i64 %138, 0
br i1 %139, label %141, label %140
140: ; preds = %134
store i8 0, i8* %136
br label %141
141: ; preds = %134, %140
%142 = add nuw nsw i64 %135, 1
%143 = icmp eq i64 %142, 17
br i1 %143, label %144, label %134
144: ; preds = %141
switch i32 %104, label %145 [
i32 1, label %193
i32 2, label %195
]
145: ; preds = %144
%146 = icmp ult i32 %104, 2
br i1 %146, label %220, label %147
147: ; preds = %145
%148 = lshr i32 %104, 1
%149 = zext i32 %148 to i64
%150 = icmp ult i32 %104, 16
br i1 %150, label %189, label %151
151: ; preds = %147
%152 = and i64 %149, 2147483640
%153 = sub nsw i64 %105, %152
br label %154
154: ; preds = %154, %151
%155 = phi i64 [ 0, %151 ], [ %179, %154 ]
%156 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %151 ], [ %177, %154 ]
%157 = phi <4 x i32> [ <i32 1, i32 1, i32 1, i32 1>, %151 ], [ %178, %154 ]
%158 = xor i64 %155, -1
%159 = add i64 %105, %158
%160 = getelementptr inbounds [17 x i8], [17 x i8]* %3, i64 0, i64 %155
%161 = bitcast i8* %160 to <4 x i8>*
%162 = load <4 x i8>, <4 x i8>* %161
%163 = getelementptr inbounds i8, i8* %160, i64 4
%164 = bitcast i8* %163 to <4 x i8>*
%165 = load <4 x i8>, <4 x i8>* %164
%166 = getelementptr inbounds [17 x i8], [17 x i8]* %3, i64 0, i64 %159
%167 = getelementptr inbounds i8, i8* %166, i64 -3
%168 = bitcast i8* %167 to <4 x i8>*
%169 = load <4 x i8>, <4 x i8>* %168
%170 = shufflevector <4 x i8> %169, <4 x i8> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%171 = getelementptr inbounds i8, i8* %166, i64 -7
%172 = bitcast i8* %171 to <4 x i8>*
%173 = load <4 x i8>, <4 x i8>* %172
%174 = shufflevector <4 x i8> %173, <4 x i8> poison, <4 x i32> <i32 3, i32 2, i32 1, i32 0>
%175 = icmp eq <4 x i8> %162, %170
%176 = icmp eq <4 x i8> %165, %174
%177 = select <4 x i1> %175, <4 x i32> %156, <4 x i32> zeroinitializer
%178 = select <4 x i1> %176, <4 x i32> %157, <4 x i32> zeroinitializer
%179 = add nuw i64 %155, 8
%180 = icmp eq i64 %179, %152
br i1 %180, label %181, label %154
181: ; preds = %154
%182 = icmp eq <4 x i32> %177, <i32 1, i32 1, i32 1, i32 1>
%183 = select <4 x i1> %182, <4 x i32> %178, <4 x i32> %177
%184 = icmp ne <4 x i32> %183, <i32 1, i32 1, i32 1, i32 1>
%185 = bitcast <4 x i1> %184 to i4
%186 = icmp eq i4 %185, 0
%187 = zext i1 %186 to i32
%188 = icmp eq i64 %152, %149
br i1 %188, label %217, label %189
189: ; preds = %147, %181
%190 = phi i64 [ 0, %147 ], [ %152, %181 ]
%191 = phi i64 [ %105, %147 ], [ %153, %181 ]
%192 = phi i32 [ 1, %147 ], [ %187, %181 ]
br label %204
193: ; preds = %144
%194 = call i32 @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %5)
br label %224
195: ; preds = %144
%196 = load i8, i8* %5
%197 = getelementptr inbounds [17 x i8], [17 x i8]* %3, i64 0, i64 1
%198 = load i8, i8* %197
%199 = icmp eq i8 %196, %198
br i1 %199, label %200, label %202
200: ; preds = %195
%201 = call i32 @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %5)
br label %224
202: ; preds = %195
%203 = add nsw i32 %0, 1
tail call void @findPal(i32 %203)
br label %224
204: ; preds = %189, %204
%205 = phi i64 [ %215, %204 ], [ %190, %189 ]
%206 = phi i64 [ %208, %204 ], [ %191, %189 ]
%207 = phi i32 [ %214, %204 ], [ %192, %189 ]
%208 = add nsw i64 %206, -1
%209 = getelementptr inbounds [17 x i8], [17 x i8]* %3, i64 0, i64 %205
%210 = load i8, i8* %209
%211 = getelementptr inbounds [17 x i8], [17 x i8]* %3, i64 0, i64 %208
%212 = load i8, i8* %211
%213 = icmp eq i8 %210, %212
%214 = select i1 %213, i32 %207, i32 0
%215 = add nuw nsw i64 %205, 1
%216 = icmp eq i64 %215, %149
br i1 %216, label %217, label %204
217: ; preds = %204, %181
%218 = phi i32 [ %187, %181 ], [ %214, %204 ]
%219 = icmp eq i32 %218, 1
br i1 %219, label %220, label %222
220: ; preds = %145, %217
%221 = call i32 @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i8* %5)
br label %224
222: ; preds = %217
%223 = add nsw i32 %0, 1
tail call void @findPal(i32 %223)
br label %224
224: ; preds = %222, %220, %202, %200, %193
ret void
}