#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*/ printf(char *, char);
int /*<<< orphan*/ scanf(char *, int *);
int main() {
  char hex[200];
  char prhex[200];
  int n, q, h, i = 1, j, z, f = 0;
  scanf("%d", &n);
  while (1) {
    q = n + f;
    f++;
    i = 1;
    while (q != 0) {
      h = q % 16;
      if (h < 10)
        h = h + 48;
      else
        h = h + 55;
      hex[i] = h;
      i++;
      q = q / 16;
    }
    h = 1;
    for (j = i - 1; j > 0; j--) {
      prhex[h] = hex[j];
      h++;
    }
    for (j = 0; j < i; j++) {
      if (prhex[j] == hex[j])
        z = 1;
      else
        z = 0;
    }
    if (z == 1) {
      for (j = 0; j < i; j++) {
        printf("%c", prhex[j]);
      }
      break;
    }
    if (z == 0) {
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<main>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1c0,%rsp
movl   $0x0,-0x4(%rbp)
movl   $0x1,-0x1b0(%rbp)
movl   $0x0,-0x1bc(%rbp)
lea    0xeb3(%rip),%rdi
lea    -0x1a4(%rbp),%rsi
call   1040 <scanf@plt>
mov    -0x1a4(%rbp),%eax
add    -0x1bc(%rbp),%eax
mov    %eax,-0x1a8(%rbp)
mov    -0x1bc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1bc(%rbp)
movl   $0x1,-0x1b0(%rbp)
cmpl   $0x0,-0x1a8(%rbp)
je     1213 <main+0xf3>
mov    -0x1a8(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    %edx,-0x1ac(%rbp)
cmpl   $0xa,-0x1ac(%rbp)
jge    11c6 <main+0xa6>
mov    -0x1ac(%rbp),%eax
add    $0x30,%eax
mov    %eax,-0x1ac(%rbp)
jmp    11d5 <main+0xb5>
mov    -0x1ac(%rbp),%eax
add    $0x37,%eax
mov    %eax,-0x1ac(%rbp)
mov    -0x1ac(%rbp),%eax
mov    %al,%cl
movslq -0x1b0(%rbp),%rax
mov    %cl,-0xd0(%rbp,%rax,1)
mov    -0x1b0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1b0(%rbp)
mov    -0x1a8(%rbp),%eax
mov    $0x10,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1a8(%rbp)
jmp    1184 <main+0x64>
movl   $0x1,-0x1ac(%rbp)
mov    -0x1b0(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x1b4(%rbp)
cmpl   $0x0,-0x1b4(%rbp)
jle    1278 <main+0x158>
movslq -0x1b4(%rbp),%rax
mov    -0xd0(%rbp,%rax,1),%cl
movslq -0x1ac(%rbp),%rax
mov    %cl,-0x1a0(%rbp,%rax,1)
mov    -0x1ac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1ac(%rbp)
mov    -0x1b4(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1b4(%rbp)
jmp    122c <main+0x10c>
movl   $0x0,-0x1b4(%rbp)
mov    -0x1b4(%rbp),%eax
cmp    -0x1b0(%rbp),%eax
jge    12ec <main+0x1cc>
movslq -0x1b4(%rbp),%rax
movsbl -0x1a0(%rbp,%rax,1),%eax
ff
movslq -0x1b4(%rbp),%rcx
movsbl -0xd0(%rbp,%rcx,1),%ecx
ff
cmp    %ecx,%eax
jne    12c9 <main+0x1a9>
movl   $0x1,-0x1b8(%rbp)
jmp    12d3 <main+0x1b3>
movl   $0x0,-0x1b8(%rbp)
jmp    12d8 <main+0x1b8>
mov    -0x1b4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1b4(%rbp)
jmp    1282 <main+0x162>
cmpl   $0x1,-0x1b8(%rbp)
jne    1349 <main+0x229>
movl   $0x0,-0x1b4(%rbp)
mov    -0x1b4(%rbp),%eax
cmp    -0x1b0(%rbp),%eax
jge    1344 <main+0x224>
movslq -0x1b4(%rbp),%rax
lea    0xce0(%rip),%rdi
movsbl -0x1a0(%rbp,%rax,1),%esi
ff
call   1030 <printf@plt>
mov    -0x1b4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1b4(%rbp)
jmp    1303 <main+0x1e3>
jmp    1360 <main+0x240>
cmpl   $0x0,-0x1b8(%rbp)
jne    135b <main+0x23b>
jmp    135b <main+0x23b>
jmp    1159 <main+0x39>
xor    %eax,%eax
add    $0x1c0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<main>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1a8,%rsp
mov    $0xfffffffe,%r12d
lea    0xec2(%rip),%rdi
lea    0xc(%rsp),%rsi
call   1040 <scanf@plt>
xor    %r10d,%r10d
mov    0xc(%rsp),%r11d
pxor   %xmm0,%xmm0
mov    %r11d,0x8(%rsp)
jmp    117f <main+0x5f>
nopl   0x0(%rax,%rax,1)
mov    $0x1,%r8d
add    $0x1,%r10d
lea    -0x1(%r8),%eax
mov    0x10(%rsp,%rax,1),%cl
cmp    0xe0(%rsp,%rax,1),%cl
je     143c <main+0x31c>
mov    %r11d,%ebp
add    %r10d,%ebp
je     1160 <main+0x40>
mov    $0x1,%r8d
mov    $0x2,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r8,%rdx
mov    %edi,%r14d
lea    0xf(%rbp),%ebx
test   %ebp,%ebp
mov    %ebp,%ecx
cmovs  %ebx,%ecx
mov    %ecx,%edi
and    $0xfffffff0,%edi
mov    %ebp,%eax
sub    %edi,%eax
lea    0x30(%rax),%esi
neg    %edi
cmp    $0xa,%eax
lea    0x37(%rbp,%rdi,1),%eax
cmovl  %esi,%eax
mov    %al,0xe0(%rsp,%r8,1)
add    $0x1,%r8
sar    $0x4,%ecx
lea    0x1(%r14),%edi
mov    %ecx,%ebp
cmp    $0x1f,%ebx
jae    11a0 <main+0x80>
cmp    $0x2,%r8d
jl     1166 <main+0x46>
mov    %r8d,%r9d
lea    -0x1(%r9),%r15
mov    $0x1,%ebx
cmp    $0x8,%r15
jae    12b0 <main+0x190>
mov    %r9,%rdi
mov    %r8d,%eax
sub    %ebx,%eax
mov    %rbx,%rdx
not    %rdx
add    %rdx,%r9
test   $0x3,%al
je     124c <main+0x12c>
mov    %r14d,%eax
sub    %bl,%al
movzbl %al,%eax
and    $0x3,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0xffffffffffffffff,%rdi
mov    %edi,%edx
movzbl 0xe0(%rsp,%rdx,1),%edx
mov    %dl,0x10(%rsp,%rbx,1)
add    $0x1,%rbx
add    $0xffffffffffffffff,%rax
jne    1230 <main+0x110>
cmp    $0x3,%r9
jb     1166 <main+0x46>
mov    %r14d,%eax
nopl   0x0(%rax)
lea    (%rdi,%r12,1),%rcx
lea    0x1(%rcx),%edx
movzbl 0xe0(%rsp,%rdx,1),%edx
mov    %dl,0x10(%rsp,%rbx,1)
mov    %ecx,%edx
movzbl 0xe0(%rsp,%rdx,1),%edx
mov    %dl,0x11(%rsp,%rbx,1)
add    $0xffffffff,%ecx
movzbl 0xe0(%rsp,%rcx,1),%ecx
mov    %cl,0x12(%rsp,%rbx,1)
add    $0xfffffffffffffffc,%rdi
mov    %edi,%ecx
movzbl 0xe0(%rsp,%rcx,1),%ecx
mov    %cl,0x13(%rsp,%rbx,1)
add    $0x4,%rbx
cmp    %rbx,%rax
jne    1260 <main+0x140>
jmp    1166 <main+0x46>
lea    -0x2(%r9),%rax
lea    -0x1(%r8),%edi
cmp    %eax,%edi
jb     1202 <main+0xe2>
shr    $0x20,%rax
mov    %r9,%rdi
jne    1205 <main+0xe5>
mov    %r14d,%r11d
cmp    $0x20,%r15
jae    12de <main+0x1be>
xor    %r13d,%r13d
jmp    13a8 <main+0x288>
mov    %r15,%r13
and    $0xffffffffffffffe0,%r13
lea    -0x1(%r11),%r12
and    $0xffffffffffffffe0,%r12
mov    %rdx,%rbx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ebx,%eax
movdqu 0xc1(%rsp,%rax,1),%xmm1
movdqu 0xd1(%rsp,%rax,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
movdqu %xmm2,0x11(%rsp,%rdi,1)
movdqu %xmm1,0x21(%rsp,%rdi,1)
add    $0x20,%rdi
add    $0xffffffffffffffe0,%rbx
cmp    %rdi,%r12
jne    1300 <main+0x1e0>
cmp    %r13,%r15
jne    13a2 <main+0x282>
mov    $0xfffffffe,%r12d
mov    0x8(%rsp),%r11d
jmp    1166 <main+0x46>
test   $0x18,%r15b
je     141f <main+0x2ff>
mov    %r8d,%r15d
add    $0xffffffffffffffff,%r15
mov    %r15,%r12
and    $0xfffffffffffffff8,%r12
lea    0x1(%r12),%rbx
mov    %r9,%rdi
sub    %r12,%rdi
sub    %r13,%rdx
add    $0xffffffffffffffff,%r11
and    $0xfffffffffffffff8,%r11
nopl   0x0(%rax)
mov    %edx,%eax
movq   0xd9(%rsp,%rax,1),%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movq   %xmm1,0x11(%rsp,%r13,1)
add    $0x8,%r13
add    $0xfffffffffffffff8,%rdx
cmp    %r13,%r11
jne    13d0 <main+0x2b0>
cmp    %r12,%r15
mov    $0xfffffffe,%r12d
mov    0x8(%rsp),%r11d
je     1166 <main+0x46>
jmp    1205 <main+0xe5>
mov    %r9,%rdi
sub    %r13,%rdi
or     $0x1,%r13
mov    %r13,%rbx
mov    $0xfffffffe,%r12d
mov    0x8(%rsp),%r11d
jmp    1205 <main+0xe5>
mov    %r8d,%r15d
xor    %ebx,%ebx
lea    0xbbb(%rip),%r14
nopl   0x0(%rax,%rax,1)
movsbl 0x10(%rsp,%rbx,1),%esi
mov    %r14,%rdi
call   1030 <printf@plt>
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1450 <main+0x330>
xor    %eax,%eax
add    $0x1a8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
@.str = [3 x i8] c"%d\00"
@.str.1 = [3 x i8] c"%c\00"
define i32 @main() {
%1 = alloca [200 x i8]
%2 = alloca [200 x i8]
%3 = alloca i32
%4 = getelementptr inbounds [200 x i8], [200 x i8]* %1, i64 0, i64 0
%5 = getelementptr inbounds [200 x i8], [200 x i8]* %2, i64 0, i64 0
%6 = bitcast i32* %3 to i8*
%7 = call i32 @scanf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str, i64 0, i64 0), i32* %3)
%8 = load i32, i32* %3
br label %9
9: ; preds = %119, %0
%10 = phi i32 [ 0, %0 ], [ %12, %119 ]
%11 = add nsw i32 %8, %10
%12 = add nuw nsw i32 %10, 1
%13 = icmp eq i32 %11, 0
br i1 %13, label %119, label %106
14: ; preds = %106
%15 = trunc i64 %115 to i32
%16 = icmp sgt i32 %15, 1
br i1 %16, label %17, label %119
17: ; preds = %14
%18 = and i64 %115, 4294967295
%19 = add nsw i64 %18, -1
%20 = icmp ult i64 %19, 8
br i1 %20, label %82, label %21
21: ; preds = %17
%22 = add nsw i64 %18, -2
%23 = add i32 %15, -1
%24 = trunc i64 %22 to i32
%25 = icmp ult i32 %23, %24
%26 = icmp ugt i64 %22, 4294967295
%27 = or i1 %25, %26
br i1 %27, label %82, label %28
28: ; preds = %21
%29 = icmp ult i64 %19, 32
br i1 %29, label %59, label %30
30: ; preds = %28
%31 = and i64 %19, -32
br label %32
32: ; preds = %32, %30
%33 = phi i64 [ 0, %30 ], [ %50, %32 ]
%34 = or i64 %33, 1
%35 = sub i64 %107, %33
%36 = and i64 %35, 4294967295
%37 = getelementptr inbounds [200 x i8], [200 x i8]* %1, i64 0, i64 %36
%38 = getelementptr inbounds i8, i8* %37, i64 -15
%39 = bitcast i8* %38 to <16 x i8>*
%40 = load <16 x i8>, <16 x i8>* %39
%41 = shufflevector <16 x i8> %40, <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>
%42 = getelementptr inbounds i8, i8* %37, i64 -31
%43 = bitcast i8* %42 to <16 x i8>*
%44 = load <16 x i8>, <16 x i8>* %43
%45 = shufflevector <16 x i8> %44, <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>
%46 = getelementptr inbounds [200 x i8], [200 x i8]* %2, i64 0, i64 %34
%47 = bitcast i8* %46 to <16 x i8>*
store <16 x i8> %41, <16 x i8>* %47
%48 = getelementptr inbounds i8, i8* %46, i64 16
%49 = bitcast i8* %48 to <16 x i8>*
store <16 x i8> %45, <16 x i8>* %49
%50 = add nuw i64 %33, 32
%51 = icmp eq i64 %50, %31
br i1 %51, label %52, label %32
52: ; preds = %32
%53 = icmp eq i64 %19, %31
br i1 %53, label %119, label %54
54: ; preds = %52
%55 = sub nsw i64 %18, %31
%56 = or i64 %31, 1
%57 = and i64 %19, 24
%58 = icmp eq i64 %57, 0
br i1 %58, label %82, label %59
59: ; preds = %28, %54
%60 = phi i64 [ %31, %54 ], [ 0, %28 ]
%61 = and i64 %115, 4294967295
%62 = add nsw i64 %61, -1
%63 = and i64 %62, -8
%64 = or i64 %63, 1
%65 = sub nsw i64 %18, %63
br label %66
66: ; preds = %66, %59
%67 = phi i64 [ %60, %59 ], [ %78, %66 ]
%68 = or i64 %67, 1
%69 = sub i64 %107, %67
%70 = and i64 %69, 4294967295
%71 = getelementptr inbounds [200 x i8], [200 x i8]* %1, i64 0, i64 %70
%72 = getelementptr inbounds i8, i8* %71, i64 -7
%73 = bitcast i8* %72 to <8 x i8>*
%74 = load <8 x i8>, <8 x i8>* %73
%75 = shufflevector <8 x i8> %74, <8 x i8> poison, <8 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0>
%76 = getelementptr inbounds [200 x i8], [200 x i8]* %2, i64 0, i64 %68
%77 = bitcast i8* %76 to <8 x i8>*
store <8 x i8> %75, <8 x i8>* %77
%78 = add nuw i64 %67, 8
%79 = icmp eq i64 %78, %63
br i1 %79, label %80, label %66
80: ; preds = %66
%81 = icmp eq i64 %62, %63
br i1 %81, label %119, label %82
82: ; preds = %21, %17, %54, %80
%83 = phi i64 [ 1, %17 ], [ 1, %21 ], [ %56, %54 ], [ %64, %80 ]
%84 = phi i64 [ %18, %17 ], [ %18, %21 ], [ %55, %54 ], [ %65, %80 ]
%85 = sub i64 %115, %83
%86 = xor i64 %83, -1
%87 = add nsw i64 %18, %86
%88 = and i64 %85, 3
%89 = icmp eq i64 %88, 0
br i1 %89, label %102, label %90
90: ; preds = %82, %90
%91 = phi i64 [ %99, %90 ], [ %83, %82 ]
%92 = phi i64 [ %94, %90 ], [ %84, %82 ]
%93 = phi i64 [ %100, %90 ], [ 0, %82 ]
%94 = add nsw i64 %92, -1
%95 = and i64 %94, 4294967295
%96 = getelementptr inbounds [200 x i8], [200 x i8]* %1, i64 0, i64 %95
%97 = load i8, i8* %96
%98 = getelementptr inbounds [200 x i8], [200 x i8]* %2, i64 0, i64 %91
store i8 %97, i8* %98
%99 = add nuw nsw i64 %91, 1
%100 = add i64 %93, 1
%101 = icmp eq i64 %100, %88
br i1 %101, label %102, label %90
102: ; preds = %90, %82
%103 = phi i64 [ %83, %82 ], [ %99, %90 ]
%104 = phi i64 [ %84, %82 ], [ %94, %90 ]
%105 = icmp ult i64 %87, 3
br i1 %105, label %119, label %128
106: ; preds = %9, %106
%107 = phi i64 [ %115, %106 ], [ 1, %9 ]
%108 = phi i32 [ %116, %106 ], [ %11, %9 ]
%109 = srem i32 %108, 16
%110 = icmp slt i32 %109, 10
%111 = select i1 %110, i32 48, i32 55
%112 = add nsw i32 %111, %109
%113 = trunc i32 %112 to i8
%114 = getelementptr inbounds [200 x i8], [200 x i8]* %1, i64 0, i64 %107
store i8 %113, i8* %114
%115 = add nuw i64 %107, 1
%116 = sdiv i32 %108, 16
%117 = add i32 %108, 15
%118 = icmp ult i32 %117, 31
br i1 %118, label %14, label %106
119: ; preds = %102, %128, %52, %80, %9, %14
%120 = phi i32 [ %15, %14 ], [ 1, %9 ], [ %15, %80 ], [ %15, %52 ], [ %15, %128 ], [ %15, %102 ]
%121 = add i32 %120, -1
%122 = zext i32 %121 to i64
%123 = getelementptr inbounds [200 x i8], [200 x i8]* %2, i64 0, i64 %122
%124 = load i8, i8* %123
%125 = getelementptr inbounds [200 x i8], [200 x i8]* %1, i64 0, i64 %122
%126 = load i8, i8* %125
%127 = icmp eq i8 %124, %126
br i1 %127, label %156, label %9
128: ; preds = %102, %128
%129 = phi i64 [ %154, %128 ], [ %103, %102 ]
%130 = phi i64 [ %149, %128 ], [ %104, %102 ]
%131 = add i64 %130, 4294967295
%132 = and i64 %131, 4294967295
%133 = getelementptr inbounds [200 x i8], [200 x i8]* %1, i64 0, i64 %132
%134 = load i8, i8* %133
%135 = getelementptr inbounds [200 x i8], [200 x i8]* %2, i64 0, i64 %129
store i8 %134, i8* %135
%136 = add nuw nsw i64 %129, 1
%137 = add i64 %130, 4294967294
%138 = and i64 %137, 4294967295
%139 = getelementptr inbounds [200 x i8], [200 x i8]* %1, i64 0, i64 %138
%140 = load i8, i8* %139
%141 = getelementptr inbounds [200 x i8], [200 x i8]* %2, i64 0, i64 %136
store i8 %140, i8* %141
%142 = add nuw nsw i64 %129, 2
%143 = add i64 %130, 4294967293
%144 = and i64 %143, 4294967295
%145 = getelementptr inbounds [200 x i8], [200 x i8]* %1, i64 0, i64 %144
%146 = load i8, i8* %145
%147 = getelementptr inbounds [200 x i8], [200 x i8]* %2, i64 0, i64 %142
store i8 %146, i8* %147
%148 = add nuw nsw i64 %129, 3
%149 = add nsw i64 %130, -4
%150 = and i64 %149, 4294967295
%151 = getelementptr inbounds [200 x i8], [200 x i8]* %1, i64 0, i64 %150
%152 = load i8, i8* %151
%153 = getelementptr inbounds [200 x i8], [200 x i8]* %2, i64 0, i64 %148
store i8 %152, i8* %153
%154 = add nuw nsw i64 %129, 4
%155 = icmp eq i64 %154, %18
br i1 %155, label %119, label %128
156: ; preds = %119
%157 = zext i32 %120 to i64
br label %158
158: ; preds = %156, %158
%159 = phi i64 [ 0, %156 ], [ %163, %158 ]
%160 = getelementptr inbounds [200 x i8], [200 x i8]* %2, i64 0, i64 %159
%161 = load i8, i8* %160
%162 = call i32 @printf(i8* getelementptr inbounds ([3 x i8], [3 x i8]* @.str.1, i64 0, i64 0), i8 signext %161)
%163 = add nuw nsw i64 %159, 1
%164 = icmp eq i64 %163, %157
br i1 %164, label %165, label %158
165: ; preds = %158
ret i32 0
}