#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 *fixed_xor(char *, char *);
int /*<<< orphan*/ printf(char *, ...);
int strlen(char *);
void single_byte_xor(char *hexString) {
  int elements = 64;
  char hex[64] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K',
                  'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V',
                  'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
                  'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
                  's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2',
                  '3', '4', '5', '6', '7', '8', '9'};
  int length = strlen(hexString);
  int i, j;
  for (i = 0; i < elements; i++) {
    char buffer[length];
    char letter = hex[i];
    if (letter >= 64 || letter <= 90) {
      for (j = 0; j < length; j += 2) {
        int num = (int)letter;
        buffer[j] = (num / 10) + '0';
        buffer[j + 1] = (num - (num / 10) * 10) + '0';
      }
    } else {
      for (j = 0; j < length; j++)
        buffer[j] = letter;
    }
    buffer[length] = '\0';
    char *result = fixed_xor(hexString, buffer);
    printf("Character used: %c\n", letter);
    printf("buffer 1: %s\nbuffer 2: %s\n", buffer, hexString);
    printf("%s\n\n", result);
  }
}


x86 assembly (clang, -O0):
<single_byte_xor>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    %rdi,-0x8(%rbp)
movl   $0x40,-0xc(%rbp)
lea    -0x50(%rbp),%rdi
lea    0xe9f(%rip),%rsi
mov    $0x40,%edx
call   1060 <memcpy@plt>
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12f7 <single_byte_xor+0x1b7>
mov    -0x54(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x68(%rbp)
mov    %rax,%rdx
add    $0xf,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x88(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x70(%rbp)
movslq -0x58(%rbp),%rax
mov    -0x50(%rbp,%rax,1),%al
mov    %al,-0x71(%rbp)
movsbl -0x71(%rbp),%eax
cmp    $0x40,%eax
jge    11d8 <single_byte_xor+0x98>
movsbl -0x71(%rbp),%eax
cmp    $0x5a,%eax
jg     1252 <single_byte_xor+0x112>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    124d <single_byte_xor+0x10d>
movsbl -0x71(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x78(%rbp),%eax
mov    $0xa,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x88(%rbp),%rax
add    $0x30,%ecx
mov    %cl,%dl
movslq -0x5c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x78(%rbp),%ecx
mov    -0x78(%rbp),%eax
mov    $0xa,%esi
cltd
idiv   %esi
mov    %eax,%edx
mov    -0x88(%rbp),%rax
imul   $0xa,%edx,%edx
sub    %edx,%ecx
add    $0x30,%ecx
mov    %cl,%dl
mov    -0x5c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x5c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x5c(%rbp)
jmp    11df <single_byte_xor+0x9f>
jmp    1289 <single_byte_xor+0x149>
movl   $0x0,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    1284 <single_byte_xor+0x144>
mov    -0x88(%rbp),%rax
mov    -0x71(%rbp),%dl
movslq -0x5c(%rbp),%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    1259 <single_byte_xor+0x119>
jmp    1289 <single_byte_xor+0x149>
mov    -0x88(%rbp),%rsi
movslq -0x54(%rbp),%rax
movb   $0x0,(%rsi,%rax,1)
mov    -0x8(%rbp),%rdi
call   1050 <fixed_xor@plt>
mov    %rax,-0x80(%rbp)
movsbl -0x71(%rbp),%esi
lea    0xd90(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x88(%rbp),%rsi
mov    -0x8(%rbp),%rdx
lea    0xd8b(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x80(%rbp),%rsi
lea    0xd94(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x68(%rbp),%rax
mov    %rax,%rsp
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    117e <single_byte_xor+0x3e>
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<single_byte_xor>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %rdi,-0x80(%rbp)
call   1030 <strlen@plt>
mov    %eax,%ecx
mov    %eax,-0x2c(%rbp)
movslq %eax,%r15
lea    -0x1(%r15),%rax
mov    %rax,-0x70(%rbp)
shr    %rax
lea    0x1(%rax),%rdx
add    $0xfffffffffffffff1,%rax
mov    %rax,-0x68(%rbp)
mov    %rax,%rsi
shr    $0x4,%rsi
add    $0x1,%rsi
mov    %rdx,-0x60(%rbp)
and    $0xfffffffffffffff0,%rdx
mov    %rdx,-0x50(%rbp)
lea    (%rdx,%rdx,1),%rax
mov    %rax,-0x48(%rbp)
mov    %rsi,%rax
mov    %rsi,-0x58(%rbp)
and    $0xfffffffffffffffe,%rsi
mov    %rsi,-0x40(%rbp)
mov    %rcx,-0x38(%rbp)
lea    0xf(%rcx),%rax
and    $0xfffffffffffffff0,%rax
mov    %rax,-0x78(%rbp)
xor    %ebx,%ebx
mov    -0x80(%rbp),%r12
jmp    121f <single_byte_xor+0xdf>
nop
movb   $0x0,0x0(%r13,%r15,1)
mov    %r12,%rdi
mov    %r13,%rsi
call   1060 <fixed_xor@plt>
mov    %r14d,%esi
mov    %rax,%r14
lea    0xe62(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe68(%rip),%rdi
mov    %r13,%rsi
mov    %r12,%rdx
xor    %eax,%eax
call   1040 <printf@plt>
lea    0xe6f(%rip),%rdi
mov    %r14,%rsi
xor    %eax,%eax
call   1040 <printf@plt>
mov    -0x88(%rbp),%rsp
add    $0x1,%rbx
cmp    $0x40,%rbx
je     1358 <single_byte_xor+0x218>
mov    %rsp,-0x88(%rbp)
mov    %rsp,%r13
sub    -0x78(%rbp),%r13
mov    %r13,%rsp
lea    0xdc9(%rip),%rax
movsbl (%rbx,%rax,1),%r14d
mov    %rbx,%rax
sub    $0x34,%rax
jb     1270 <single_byte_xor+0x130>
cmp    $0xffffffffffffffe6,%rax
jb     1270 <single_byte_xor+0x130>
cmpl   $0x0,-0x38(%rbp)
jle    11c0 <single_byte_xor+0x80>
mov    %r13,%rdi
mov    %r14d,%esi
mov    -0x38(%rbp),%rdx
call   1050 <memset@plt>
jmp    11c0 <single_byte_xor+0x80>
nopl   0x0(%rax)
cmpl   $0x0,-0x2c(%rbp)
jle    11c0 <single_byte_xor+0x80>
imul   $0x67,%r14d,%eax
movzwl %ax,%ecx
shr    $0xa,%eax
shr    $0xf,%ecx
add    %al,%cl
movzbl %cl,%ecx
lea    0x30(%rcx),%eax
add    %ecx,%ecx
lea    (%rcx,%rcx,4),%ecx
neg    %ecx
add    %r14b,%cl
add    $0x30,%cl
cmpq   $0x1e,-0x70(%rbp)
jae    12aa <single_byte_xor+0x16a>
xor    %edx,%edx
jmp    1340 <single_byte_xor+0x200>
movzbl %al,%edx
movd   %edx,%xmm0
punpcklbw %xmm0,%xmm0
pshuflw $0x0,%xmm0,%xmm0
movzbl %cl,%edx
movd   %edx,%xmm1
punpcklbw %xmm1,%xmm1
pshuflw $0x0,%xmm1,%xmm1
punpcklbw %xmm1,%xmm0
cmpq   $0x10,-0x68(%rbp)
jae    12d9 <single_byte_xor+0x199>
xor    %edx,%edx
jmp    1306 <single_byte_xor+0x1c6>
mov    -0x40(%rbp),%rsi
xor    %edx,%edx
nop
movdqa %xmm0,0x0(%r13,%rdx,2)
movdqa %xmm0,0x10(%r13,%rdx,2)
movdqa %xmm0,0x20(%r13,%rdx,2)
movdqa %xmm0,0x30(%r13,%rdx,2)
add    $0x20,%rdx
add    $0xfffffffffffffffe,%rsi
jne    12e0 <single_byte_xor+0x1a0>
testb  $0x1,-0x58(%rbp)
je     1322 <single_byte_xor+0x1e2>
lea    (%rdx,%rdx,1),%rsi
or     $0x11,%rsi
movdqa %xmm0,0x0(%r13,%rdx,2)
movdqa %xmm0,-0x1(%r13,%rsi,1)
mov    -0x48(%rbp),%rdx
mov    -0x50(%rbp),%rsi
cmp    %rsi,-0x60(%rbp)
je     11c0 <single_byte_xor+0x80>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %al,0x0(%r13,%rdx,1)
mov    %cl,0x1(%r13,%rdx,1)
add    $0x2,%rdx
cmp    %r15,%rdx
jl     1340 <single_byte_xor+0x200>
jmp    11c0 <single_byte_xor+0x80>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@__const.single_byte_xor.hex = [64 x i8] c"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\00\00"
@.str = [20 x i8] c"Character used: %c\0A\00"
@.str.1 = [27 x i8] c"buffer 1: %s\0Abuffer 2: %s\0A\00"
@.str.2 = [5 x i8] c"%s\0A\0A\00"
define void @single_byte_xor(i8* %0) {
%2 = alloca i8*
%3 = alloca i32
%4 = alloca [64 x i8]
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i8*
%9 = alloca i64
%10 = alloca i8
%11 = alloca i32
%12 = alloca i8*
store i8* %0, i8** %2
store i32 64, i32* %3
%13 = bitcast [64 x i8]* %4 to i8*
%14 = load i8*, i8** %2
%15 = call i32 @strlen(i8* %14)
store i32 %15, i32* %5
store i32 0, i32* %6
br label %16
16: ; preds = %94, %1
%17 = load i32, i32* %6
%18 = load i32, i32* %3
%19 = icmp slt i32 %17, %18
br i1 %19, label %20, label %97
20: ; preds = %16
%21 = load i32, i32* %5
%22 = zext i32 %21 to i64
%23 = call i8* @llvm.stacksave()
store i8* %23, i8** %8
%24 = alloca i8, i64 %22
store i64 %22, i64* %9
%25 = load i32, i32* %6
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds [64 x i8], [64 x i8]* %4, i64 0, i64 %26
%28 = load i8, i8* %27
store i8 %28, i8* %10
%29 = load i8, i8* %10
%30 = sext i8 %29 to i32
%31 = icmp sge i32 %30, 64
br i1 %31, label %36, label %32
32: ; preds = %20
%33 = load i8, i8* %10
%34 = sext i8 %33 to i32
%35 = icmp sle i32 %34, 90
br i1 %35, label %36, label %66
36: ; preds = %32, %20
store i32 0, i32* %7
br label %37
37: ; preds = %62, %36
%38 = load i32, i32* %7
%39 = load i32, i32* %5
%40 = icmp slt i32 %38, %39
br i1 %40, label %41, label %65
41: ; preds = %37
%42 = load i8, i8* %10
%43 = sext i8 %42 to i32
store i32 %43, i32* %11
%44 = load i32, i32* %11
%45 = sdiv i32 %44, 10
%46 = add nsw i32 %45, 48
%47 = trunc i32 %46 to i8
%48 = load i32, i32* %7
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i8, i8* %24, i64 %49
store i8 %47, i8* %50
%51 = load i32, i32* %11
%52 = load i32, i32* %11
%53 = sdiv i32 %52, 10
%54 = mul nsw i32 %53, 10
%55 = sub nsw i32 %51, %54
%56 = add nsw i32 %55, 48
%57 = trunc i32 %56 to i8
%58 = load i32, i32* %7
%59 = add nsw i32 %58, 1
%60 = sext i32 %59 to i64
%61 = getelementptr inbounds i8, i8* %24, i64 %60
store i8 %57, i8* %61
br label %62
62: ; preds = %41
%63 = load i32, i32* %7
%64 = add nsw i32 %63, 2
store i32 %64, i32* %7
br label %37
65: ; preds = %37
br label %80
66: ; preds = %32
store i32 0, i32* %7
br label %67
67: ; preds = %76, %66
%68 = load i32, i32* %7
%69 = load i32, i32* %5
%70 = icmp slt i32 %68, %69
br i1 %70, label %71, label %79
71: ; preds = %67
%72 = load i8, i8* %10
%73 = load i32, i32* %7
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds i8, i8* %24, i64 %74
store i8 %72, i8* %75
br label %76
76: ; preds = %71
%77 = load i32, i32* %7
%78 = add nsw i32 %77, 1
store i32 %78, i32* %7
br label %67
79: ; preds = %67
br label %80
80: ; preds = %79, %65
%81 = load i32, i32* %5
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds i8, i8* %24, i64 %82
store i8 0, i8* %83
%84 = load i8*, i8** %2
%85 = call i8* @fixed_xor(i8* %84, i8* %24)
store i8* %85, i8** %12
%86 = load i8, i8* %10
%87 = sext i8 %86 to i32
%88 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.str, i64 0, i64 0), i32 %87)
%89 = load i8*, i8** %2
%90 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([27 x i8], [27 x i8]* @.str.1, i64 0, i64 0), i8* %24, i8* %89)
%91 = load i8*, i8** %12
%92 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i8* %91)
%93 = load i8*, i8** %8
br label %94
94: ; preds = %80
%95 = load i32, i32* %6
%96 = add nsw i32 %95, 1
store i32 %96, i32* %6
br label %16
97: ; preds = %16
ret void
}

LLVM IR (-O2):
@__const.single_byte_xor.hex = [64 x i8] c"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789\00\00"
@.str = [20 x i8] c"Character used: %c\0A\00"
@.str.1 = [27 x i8] c"buffer 1: %s\0Abuffer 2: %s\0A\00"
@.str.2 = [5 x i8] c"%s\0A\0A\00"
define void @single_byte_xor(i8* %0) {
%2 = tail call i32 @strlen(i8* %0)
%3 = zext i32 %2 to i64
%4 = sext i32 %2 to i64
%5 = icmp sgt i32 %2, 0
%6 = add nsw i64 %4, -1
%7 = lshr i64 %6, 1
%8 = add nuw i64 %7, 1
%9 = add nsw i64 %7, -15
%10 = lshr i64 %9, 4
%11 = add nuw nsw i64 %10, 1
%12 = icmp ult i64 %6, 30
%13 = and i64 %8, -16
%14 = shl i64 %13, 1
%15 = and i64 %11, 1
%16 = icmp ult i64 %9, 16
%17 = and i64 %11, 2305843009213693950
%18 = icmp eq i64 %15, 0
%19 = icmp eq i64 %8, %13
br label %20
20: ; preds = %1, %102
%21 = phi i64 [ 0, %1 ], [ %108, %102 ]
%22 = call i8* @llvm.stacksave()
%23 = alloca i8, i64 %3
%24 = getelementptr inbounds [64 x i8], [64 x i8]* @__const.single_byte_xor.hex, i64 0, i64 %21
%25 = load i8, i8* %24
%26 = sext i8 %25 to i32
%27 = icmp ult i64 %21, 52
%28 = add nsw i64 %21, -52
%29 = icmp ult i64 %28, -26
%30 = select i1 %27, i1 true, i1 %29
br i1 %30, label %33, label %31
31: ; preds = %20
br i1 %5, label %32, label %102
32: ; preds = %31
br label %102
33: ; preds = %20
br i1 %5, label %34, label %102
34: ; preds = %33
%35 = sdiv i8 %25, 10
%36 = add nsw i8 %35, 48
%37 = mul nsw i8 %35, -10
%38 = add i8 %25, 48
%39 = add i8 %38, %37
br i1 %12, label %93, label %40
40: ; preds = %34
%41 = insertelement <8 x i8> poison, i8 %36, i64 0
%42 = shufflevector <8 x i8> %41, <8 x i8> poison, <8 x i32> zeroinitializer
%43 = insertelement <8 x i8> poison, i8 %39, i64 0
%44 = shufflevector <8 x i8> %43, <8 x i8> poison, <8 x i32> zeroinitializer
%45 = insertelement <8 x i8> poison, i8 %36, i64 0
%46 = shufflevector <8 x i8> %45, <8 x i8> poison, <8 x i32> zeroinitializer
%47 = insertelement <8 x i8> poison, i8 %39, i64 0
%48 = shufflevector <8 x i8> %47, <8 x i8> poison, <8 x i32> zeroinitializer
br i1 %16, label %78, label %49
49: ; preds = %40
%50 = getelementptr inbounds i8, i8* %23, i64 -1
%51 = getelementptr inbounds i8, i8* %23, i64 -1
%52 = shufflevector <8 x i8> %42, <8 x i8> %44, <16 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11, i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
%53 = shufflevector <8 x i8> %46, <8 x i8> %48, <16 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11, i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
%54 = getelementptr inbounds i8, i8* %23, i64 -1
%55 = getelementptr inbounds i8, i8* %23, i64 -1
%56 = shufflevector <8 x i8> %42, <8 x i8> %44, <16 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11, i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
%57 = shufflevector <8 x i8> %46, <8 x i8> %48, <16 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11, i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
br label %58
58: ; preds = %58, %49
%59 = phi i64 [ 0, %49 ], [ %75, %58 ]
%60 = phi i64 [ 0, %49 ], [ %76, %58 ]
%61 = shl i64 %59, 1
%62 = or i64 %61, 1
%63 = or i64 %61, 17
%64 = getelementptr inbounds i8, i8* %50, i64 %62
%65 = bitcast i8* %64 to <16 x i8>*
%66 = getelementptr inbounds i8, i8* %51, i64 %63
%67 = bitcast i8* %66 to <16 x i8>*
store <16 x i8> %52, <16 x i8>* %65
store <16 x i8> %53, <16 x i8>* %67
%68 = shl i64 %59, 1
%69 = or i64 %68, 33
%70 = or i64 %68, 49
%71 = getelementptr inbounds i8, i8* %54, i64 %69
%72 = bitcast i8* %71 to <16 x i8>*
%73 = getelementptr inbounds i8, i8* %55, i64 %70
%74 = bitcast i8* %73 to <16 x i8>*
store <16 x i8> %56, <16 x i8>* %72
store <16 x i8> %57, <16 x i8>* %74
%75 = add nuw i64 %59, 32
%76 = add i64 %60, 2
%77 = icmp eq i64 %76, %17
br i1 %77, label %78, label %58
78: ; preds = %58, %40
%79 = phi i64 [ 0, %40 ], [ %75, %58 ]
br i1 %18, label %92, label %80
80: ; preds = %78
%81 = shl i64 %79, 1
%82 = or i64 %81, 1
%83 = or i64 %81, 17
%84 = getelementptr inbounds i8, i8* %23, i64 -1
%85 = getelementptr inbounds i8, i8* %23, i64 -1
%86 = getelementptr inbounds i8, i8* %84, i64 %82
%87 = bitcast i8* %86 to <16 x i8>*
%88 = getelementptr inbounds i8, i8* %85, i64 %83
%89 = bitcast i8* %88 to <16 x i8>*
%90 = shufflevector <8 x i8> %42, <8 x i8> %44, <16 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11, i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
store <16 x i8> %90, <16 x i8>* %87
%91 = shufflevector <8 x i8> %46, <8 x i8> %48, <16 x i32> <i32 0, i32 8, i32 1, i32 9, i32 2, i32 10, i32 3, i32 11, i32 4, i32 12, i32 5, i32 13, i32 6, i32 14, i32 7, i32 15>
store <16 x i8> %91, <16 x i8>* %89
br label %92
92: ; preds = %78, %80
br i1 %19, label %102, label %93
93: ; preds = %34, %92
%94 = phi i64 [ 0, %34 ], [ %14, %92 ]
br label %95
95: ; preds = %93, %95
%96 = phi i64 [ %100, %95 ], [ %94, %93 ]
%97 = getelementptr inbounds i8, i8* %23, i64 %96
store i8 %36, i8* %97
%98 = or i64 %96, 1
%99 = getelementptr inbounds i8, i8* %23, i64 %98
store i8 %39, i8* %99
%100 = add nuw nsw i64 %96, 2
%101 = icmp slt i64 %100, %4
br i1 %101, label %95, label %102
102: ; preds = %95, %92, %32, %31, %33
%103 = getelementptr inbounds i8, i8* %23, i64 %4
store i8 0, i8* %103
%104 = call i8* @fixed_xor(i8* %0, i8* %23)
%105 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([20 x i8], [20 x i8]* @.str, i64 0, i64 0), i32 %26)
%106 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([27 x i8], [27 x i8]* @.str.1, i64 0, i64 0), i8* %23, i8* %0)
%107 = call i32 (i8*, ...) @printf(i8* dereferenceable(1) getelementptr inbounds ([5 x i8], [5 x i8]* @.str.2, i64 0, i64 0), i8* %104)
%108 = add nuw nsw i64 %21, 1
%109 = icmp eq i64 %108, 64
br i1 %109, label %110, label %20
110: ; preds = %102
ret void
}