#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*/ memcpy(unsigned char *, unsigned char const *, int);
int present_enc(unsigned char state[8], const unsigned char userkey[10]) {
  unsigned char key[10];
  memcpy(key, userkey, 10);
  const unsigned char sBox4[] = {0xc, 0x5, 0x6, 0xb, 0x9, 0x0, 0xa, 0xd,
                                 0x3, 0xe, 0xf, 0x8, 0x4, 0x7, 0x1, 0x2};
  unsigned char i = 0;
  unsigned char position = 0;
  unsigned char element_source = 0;
  unsigned char bit_source = 0;
  unsigned char element_destination = 0;
  unsigned char bit_destination = 0;
  unsigned char temp_pLayer[8];
  unsigned char round;
  unsigned char save1;
  unsigned char save2;
  round = 0;
  do {
    i = 0;
    do {
      state[i] = state[i] ^ key[i + 2];
      i++;
    } while (i <= 7);
    do {
      i--;
      state[i] = sBox4[state[i] >> 4] << 4 | sBox4[state[i] & 0xF];
    } while (i > 0);
    for (i = 0; i < 8; i++) {
      temp_pLayer[i] = 0;
    }
    for (i = 0; i < 64; i++) {
      position = (16 * i) % 63;
      if (i == 63)
        position = 63;
      element_source = i / 8;
      bit_source = i % 8;
      element_destination = position / 8;
      bit_destination = position % 8;
      temp_pLayer[element_destination] |=
          ((state[element_source] >> bit_source) & 0x1) << bit_destination;
    }
    for (i = 0; i <= 7; i++) {
      state[i] = temp_pLayer[i];
    }
    save1 = key[0];
    save2 = key[1];
    i = 0;
    do {
      key[i] = key[i + 2];
      i++;
    } while (i < 8);
    key[8] = save1;
    key[9] = save2;
    i = 0;
    save1 = key[0] & 7;
    do {
      key[i] = key[i] >> 3 | key[i + 1] << 5;
      i++;
    } while (i < 9);
    key[9] = key[9] >> 3 | save1 << 5;
    key[9] = sBox4[key[9] >> 4] << 4 | (key[9] & 0xF);
    if ((round + 1) % 2 == 1)
      key[1] ^= 128;
    key[2] = ((((round + 1) >> 1) ^ (key[2] & 15)) | (key[2] & 240));
    round++;
  } while (round < 31);
  i = 0;
  do {
    state[i] = state[i] ^ key[i + 2];
    i++;
  } while (i <= 7);
  return 0;
}


x86 assembly (clang, -O0):
<present_enc>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
lea    -0x1a(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    $0xa,%edx
call   1030 <memcpy@plt>
mov    0xec7(%rip),%rax
mov    %rax,-0x30(%rbp)
mov    0xec4(%rip),%rax
mov    %rax,-0x28(%rbp)
movb   $0x0,-0x31(%rbp)
movb   $0x0,-0x32(%rbp)
movb   $0x0,-0x33(%rbp)
movb   $0x0,-0x34(%rbp)
movb   $0x0,-0x35(%rbp)
movb   $0x0,-0x36(%rbp)
movb   $0x0,-0x3f(%rbp)
movb   $0x0,-0x31(%rbp)
mov    -0x8(%rbp),%rax
movzbl -0x31(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x31(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl -0x1a(%rbp,%rcx,1),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movzbl -0x31(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x31(%rbp),%al
add    $0x1,%al
mov    %al,-0x31(%rbp)
movzbl -0x31(%rbp),%eax
cmp    $0x7,%eax
jle    1168 <present_enc+0x58>
jmp    11ac <present_enc+0x9c>
mov    -0x31(%rbp),%al
add    $0xff,%al
mov    %al,-0x31(%rbp)
mov    -0x8(%rbp),%rax
movzbl -0x31(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
sar    $0x4,%eax
cltq
movzbl -0x30(%rbp,%rax,1),%eax
shl    $0x4,%eax
mov    -0x8(%rbp),%rcx
movzbl -0x31(%rbp),%edx
movzbl (%rcx,%rdx,1),%ecx
and    $0xf,%ecx
movslq %ecx,%rcx
movzbl -0x30(%rbp,%rcx,1),%ecx
or     %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movzbl -0x31(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
movzbl -0x31(%rbp),%eax
cmp    $0x0,%eax
jg     11ac <present_enc+0x9c>
movb   $0x0,-0x31(%rbp)
movzbl -0x31(%rbp),%eax
cmp    $0x8,%eax
jge    1227 <present_enc+0x117>
movzbl -0x31(%rbp),%eax
movb   $0x0,-0x3e(%rbp,%rax,1)
mov    -0x31(%rbp),%al
add    $0x1,%al
mov    %al,-0x31(%rbp)
jmp    1204 <present_enc+0xf4>
movb   $0x0,-0x31(%rbp)
movzbl -0x31(%rbp),%eax
cmp    $0x40,%eax
jge    12d4 <present_enc+0x1c4>
movzbl -0x31(%rbp),%eax
shl    $0x4,%eax
mov    $0x3f,%ecx
cltd
idiv   %ecx
mov    %dl,%al
mov    %al,-0x32(%rbp)
movzbl -0x31(%rbp),%eax
cmp    $0x3f,%eax
jne    125d <present_enc+0x14d>
movb   $0x3f,-0x32(%rbp)
movzbl -0x31(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %al,-0x33(%rbp)
movzbl -0x31(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %dl,%al
mov    %al,-0x34(%rbp)
movzbl -0x32(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %al,-0x35(%rbp)
movzbl -0x32(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %dl,%al
mov    %al,-0x36(%rbp)
mov    -0x8(%rbp),%rax
movzbl -0x33(%rbp),%ecx
movzbl (%rax,%rcx,1),%edx
movzbl -0x34(%rbp),%ecx
sar    %cl,%edx
and    $0x1,%edx
movzbl -0x36(%rbp),%ecx
shl    %cl,%edx
movzbl -0x35(%rbp),%eax
movzbl -0x3e(%rbp,%rax,1),%ecx
or     %edx,%ecx
mov    %cl,-0x3e(%rbp,%rax,1)
mov    -0x31(%rbp),%al
add    $0x1,%al
mov    %al,-0x31(%rbp)
jmp    122b <present_enc+0x11b>
movb   $0x0,-0x31(%rbp)
movzbl -0x31(%rbp),%eax
cmp    $0x7,%eax
jg     1305 <present_enc+0x1f5>
movzbl -0x31(%rbp),%eax
mov    -0x3e(%rbp,%rax,1),%dl
mov    -0x8(%rbp),%rax
movzbl -0x31(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x31(%rbp),%al
add    $0x1,%al
mov    %al,-0x31(%rbp)
jmp    12d8 <present_enc+0x1c8>
mov    -0x1a(%rbp),%al
mov    %al,-0x40(%rbp)
mov    -0x19(%rbp),%al
mov    %al,-0x41(%rbp)
movb   $0x0,-0x31(%rbp)
movzbl -0x31(%rbp),%eax
add    $0x2,%eax
cltq
mov    -0x1a(%rbp,%rax,1),%cl
movzbl -0x31(%rbp),%eax
mov    %cl,-0x1a(%rbp,%rax,1)
mov    -0x31(%rbp),%al
add    $0x1,%al
mov    %al,-0x31(%rbp)
movzbl -0x31(%rbp),%eax
cmp    $0x8,%eax
jl     1315 <present_enc+0x205>
mov    -0x40(%rbp),%al
mov    %al,-0x12(%rbp)
mov    -0x41(%rbp),%al
mov    %al,-0x11(%rbp)
movb   $0x0,-0x31(%rbp)
movzbl -0x1a(%rbp),%eax
and    $0x7,%eax
mov    %al,-0x40(%rbp)
movzbl -0x31(%rbp),%eax
movzbl -0x1a(%rbp,%rax,1),%eax
sar    $0x3,%eax
movzbl -0x31(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movzbl -0x1a(%rbp,%rcx,1),%ecx
shl    $0x5,%ecx
or     %ecx,%eax
mov    %al,%cl
movzbl -0x31(%rbp),%eax
mov    %cl,-0x1a(%rbp,%rax,1)
mov    -0x31(%rbp),%al
add    $0x1,%al
mov    %al,-0x31(%rbp)
movzbl -0x31(%rbp),%eax
cmp    $0x9,%eax
jl     1359 <present_enc+0x249>
movzbl -0x11(%rbp),%eax
sar    $0x3,%eax
movzbl -0x40(%rbp),%ecx
shl    $0x5,%ecx
or     %ecx,%eax
mov    %al,-0x11(%rbp)
movzbl -0x11(%rbp),%eax
sar    $0x4,%eax
cltq
movzbl -0x30(%rbp,%rax,1),%eax
shl    $0x4,%eax
movzbl -0x11(%rbp),%ecx
and    $0xf,%ecx
or     %ecx,%eax
mov    %al,-0x11(%rbp)
movzbl -0x3f(%rbp),%eax
add    $0x1,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x1,%edx
jne    13ec <present_enc+0x2dc>
movzbl -0x19(%rbp),%eax
xor    $0x80,%eax
mov    %al,-0x19(%rbp)
movzbl -0x3f(%rbp),%eax
add    $0x1,%eax
sar    $0x1,%eax
movzbl -0x18(%rbp),%ecx
and    $0xf,%ecx
xor    %ecx,%eax
movzbl -0x18(%rbp),%ecx
and    $0xf0,%ecx
or     %ecx,%eax
mov    %al,-0x18(%rbp)
mov    -0x3f(%rbp),%al
add    $0x1,%al
mov    %al,-0x3f(%rbp)
movzbl -0x3f(%rbp),%eax
cmp    $0x1f,%eax
jl     1164 <present_enc+0x54>
movb   $0x0,-0x31(%rbp)
mov    -0x8(%rbp),%rax
movzbl -0x31(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x31(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movzbl -0x1a(%rbp,%rcx,1),%ecx
xor    %ecx,%eax
mov    %al,%dl
mov    -0x8(%rbp),%rax
movzbl -0x31(%rbp),%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x31(%rbp),%al
add    $0x1,%al
mov    %al,-0x31(%rbp)
movzbl -0x31(%rbp),%eax
cmp    $0x7,%eax
jle    1427 <present_enc+0x317>
xor    %eax,%eax
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<present_enc>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdi,%rbx
mov    %rsp,%rdi
mov    $0xa,%edx
call   1030 <memcpy@plt>
mov    0x2(%rsp),%sil
mov    0x3(%rsp),%r10b
mov    0x4(%rsp),%r11b
mov    0x5(%rsp),%r9b
mov    0x6(%rsp),%r8b
mov    0x7(%rsp),%r15b
mov    0x8(%rsp),%r12b
xor    %ebp,%ebp
mov    0x9(%rsp),%dil
lea    0xea1(%rip),%rdx
mov    $0x3f,%r14d
jmp    1192 <present_enc+0x82>
nopw   0x0(%rax,%rax,1)
mov    %ebp,%eax
shr    %eax
movzbl %sil,%esi
mov    %esi,%ecx
and    $0xf,%ecx
xor    %eax,%ecx
and    $0xfffffff0,%esi
or     %ecx,%esi
mov    %sil,0x2(%rsp)
cmp    $0x1f,%ebp
je     141a <present_enc+0x30a>
mov    %ebp,0xc(%rsp)
xor    (%rbx),%sil
xor    0x1(%rbx),%r10b
xor    0x2(%rbx),%r11b
xor    0x3(%rbx),%r9b
xor    0x4(%rbx),%r8b
xor    0x5(%rbx),%r15b
xor    0x6(%rbx),%r12b
xor    0x7(%rbx),%dil
movzbl %dil,%ecx
mov    %rcx,%rdi
shr    $0x4,%rdi
mov    (%rdi,%rdx,1),%al
shl    $0x4,%al
and    $0xf,%ecx
or     (%rcx,%rdx,1),%al
mov    %al,0x7(%rbx)
movzbl %r12b,%eax
mov    %rax,%rcx
shr    $0x4,%rcx
mov    (%rcx,%rdx,1),%cl
shl    $0x4,%cl
and    $0xf,%eax
or     (%rax,%rdx,1),%cl
mov    %cl,0x6(%rbx)
movzbl %r15b,%eax
mov    %rax,%rcx
shr    $0x4,%rcx
mov    (%rcx,%rdx,1),%cl
shl    $0x4,%cl
and    $0xf,%eax
or     (%rax,%rdx,1),%cl
mov    %cl,0x5(%rbx)
movzbl %r8b,%eax
mov    %rax,%rcx
shr    $0x4,%rcx
mov    (%rcx,%rdx,1),%cl
shl    $0x4,%cl
and    $0xf,%eax
or     (%rax,%rdx,1),%cl
mov    %cl,0x4(%rbx)
movzbl %r9b,%eax
mov    %rax,%rcx
shr    $0x4,%rcx
mov    (%rcx,%rdx,1),%cl
shl    $0x4,%cl
and    $0xf,%eax
or     (%rax,%rdx,1),%cl
mov    %cl,0x3(%rbx)
movzbl %r11b,%eax
mov    %rax,%rcx
shr    $0x4,%rcx
mov    (%rcx,%rdx,1),%cl
shl    $0x4,%cl
and    $0xf,%eax
or     (%rax,%rdx,1),%cl
mov    %cl,0x2(%rbx)
movzbl %r10b,%eax
mov    %rax,%rcx
shr    $0x4,%rcx
mov    (%rcx,%rdx,1),%cl
shl    $0x4,%cl
and    $0xf,%eax
or     (%rax,%rdx,1),%cl
mov    %cl,0x1(%rbx)
movzbl %sil,%eax
mov    %rax,%rcx
shr    $0x4,%rcx
mov    (%rcx,%rdx,1),%cl
shl    $0x4,%cl
and    $0xf,%eax
or     (%rax,%rdx,1),%cl
mov    %cl,(%rbx)
movq   $0x0,0x10(%rsp)
xor    %edx,%edx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzwl %dx,%eax
imul   $0x411,%eax,%ecx
shr    $0x10,%ecx
mov    %edx,%eax
sub    %ecx,%eax
movzwl %ax,%eax
shr    %eax
add    %ecx,%eax
shr    $0x5,%eax
mov    %eax,%ecx
shl    $0x6,%ecx
sub    %ecx,%eax
add    %edx,%eax
cmp    $0x3f,%si
cmove  %r14d,%eax
mov    %esi,%ecx
shr    $0x3,%ecx
movzwl %ax,%edi
and    $0x1f,%ecx
movzbl (%rbx,%rcx,1),%ebp
mov    %esi,%ecx
and    $0x7,%cl
shr    %cl,%ebp
and    $0x1,%ebp
and    $0x7,%al
mov    %eax,%ecx
shl    %cl,%ebp
shr    $0x3,%rdi
or     %bpl,0x10(%rsp,%rdi,1)
add    $0x1,%esi
add    $0x10,%edx
cmp    $0x40,%si
jne    12a0 <present_enc+0x190>
mov    0x10(%rsp),%rax
mov    %rax,(%rbx)
mov    (%rsp),%r13b
mov    0x1(%rsp),%bpl
mov    0x2(%rsp),%rdi
mov    %rdi,(%rsp)
mov    %edi,%eax
shr    $0x3,%al
mov    0x1(%rsp),%cl
mov    0x2(%rsp),%r8b
mov    %ecx,%edx
shl    $0x5,%dl
or     %al,%dl
mov    %dl,(%rsp)
shr    $0x3,%cl
mov    %r8d,%eax
shl    $0x5,%al
or     %cl,%al
mov    %al,0x1(%rsp)
mov    0x3(%rsp),%cl
shr    $0x3,%r8b
mov    %ecx,%esi
shl    $0x5,%sil
or     %r8b,%sil
mov    0x4(%rsp),%dl
shr    $0x3,%cl
mov    %edx,%r10d
shl    $0x5,%r10b
or     %cl,%r10b
mov    %r10b,0x3(%rsp)
mov    0x5(%rsp),%cl
shr    $0x3,%dl
mov    %ecx,%r11d
shl    $0x5,%r11b
or     %dl,%r11b
mov    %r11b,0x4(%rsp)
mov    0x6(%rsp),%dl
shr    $0x3,%cl
mov    %edx,%r9d
shl    $0x5,%r9b
or     %cl,%r9b
mov    %r9b,0x5(%rsp)
mov    0x7(%rsp),%r15b
shr    $0x3,%dl
mov    %r15d,%r8d
shl    $0x5,%r8b
or     %dl,%r8b
mov    %r8b,0x6(%rsp)
mov    %r13d,%ecx
shl    $0x5,%cl
shr    $0x3,%r15b
or     %cl,%r15b
mov    %r15b,0x7(%rsp)
shr    $0x3,%r13b
mov    %ebp,%r12d
shl    $0x5,%r12b
or     %r13b,%r12b
mov    %r12b,0x8(%rsp)
shr    $0x3,%bpl
shl    $0x5,%dil
or     %bpl,%dil
movzbl %dil,%edi
mov    %rdi,%rcx
shr    $0x4,%rcx
lea    0xc14(%rip),%rdx
mov    (%rcx,%rdx,1),%cl
shl    $0x4,%cl
and    $0xf,%dil
or     %cl,%dil
mov    %dil,0x9(%rsp)
mov    0xc(%rsp),%ebp
add    $0x1,%ebp
test   $0x1,%bpl
je     1170 <present_enc+0x60>
xor    $0x80,%al
mov    %al,0x1(%rsp)
jmp    1170 <present_enc+0x60>
xor    %sil,(%rbx)
xor    %r10b,0x1(%rbx)
xor    %r11b,0x2(%rbx)
xor    %r9b,0x3(%rbx)
xor    %r8b,0x4(%rbx)
xor    %r15b,0x5(%rbx)
xor    %r12b,0x6(%rbx)
xor    %dil,0x7(%rbx)
xor    %eax,%eax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@__const.present_enc.sBox4 = [16 x i8] c"\0C\05\06\0B\09\00\0A\0D\03\0E\0F\08\04\07\01\02"
define i32 @present_enc(i8* %0, i8* %1) {
%3 = alloca i8*
%4 = alloca i8*
%5 = alloca [10 x i8]
%6 = alloca [16 x i8]
%7 = alloca i8
%8 = alloca i8
%9 = alloca i8
%10 = alloca i8
%11 = alloca i8
%12 = alloca i8
%13 = alloca [8 x i8]
%14 = alloca i8
%15 = alloca i8
%16 = alloca i8
store i8* %0, i8** %3
store i8* %1, i8** %4
%17 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 0
%18 = load i8*, i8** %4
%19 = call i32 @memcpy(i8* %17, i8* %18, i32 10)
%20 = bitcast [16 x i8]* %6 to i8*
store i8 0, i8* %7
store i8 0, i8* %8
store i8 0, i8* %9
store i8 0, i8* %10
store i8 0, i8* %11
store i8 0, i8* %12
store i8 0, i8* %14
br label %21
21: ; preds = %283, %2
store i8 0, i8* %7
br label %22
22: ; preds = %44, %21
%23 = load i8*, i8** %3
%24 = load i8, i8* %7
%25 = zext i8 %24 to i64
%26 = getelementptr inbounds i8, i8* %23, i64 %25
%27 = load i8, i8* %26
%28 = zext i8 %27 to i32
%29 = load i8, i8* %7
%30 = zext i8 %29 to i32
%31 = add nsw i32 %30, 2
%32 = sext i32 %31 to i64
%33 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 %32
%34 = load i8, i8* %33
%35 = zext i8 %34 to i32
%36 = xor i32 %28, %35
%37 = trunc i32 %36 to i8
%38 = load i8*, i8** %3
%39 = load i8, i8* %7
%40 = zext i8 %39 to i64
%41 = getelementptr inbounds i8, i8* %38, i64 %40
store i8 %37, i8* %41
%42 = load i8, i8* %7
%43 = add i8 %42, 1
store i8 %43, i8* %7
br label %44
44: ; preds = %22
%45 = load i8, i8* %7
%46 = zext i8 %45 to i32
%47 = icmp sle i32 %46, 7
br i1 %47, label %22, label %48
48: ; preds = %44
br label %49
49: ; preds = %81, %48
%50 = load i8, i8* %7
%51 = add i8 %50, -1
store i8 %51, i8* %7
%52 = load i8*, i8** %3
%53 = load i8, i8* %7
%54 = zext i8 %53 to i64
%55 = getelementptr inbounds i8, i8* %52, i64 %54
%56 = load i8, i8* %55
%57 = zext i8 %56 to i32
%58 = ashr i32 %57, 4
%59 = sext i32 %58 to i64
%60 = getelementptr inbounds [16 x i8], [16 x i8]* %6, i64 0, i64 %59
%61 = load i8, i8* %60
%62 = zext i8 %61 to i32
%63 = shl i32 %62, 4
%64 = load i8*, i8** %3
%65 = load i8, i8* %7
%66 = zext i8 %65 to i64
%67 = getelementptr inbounds i8, i8* %64, i64 %66
%68 = load i8, i8* %67
%69 = zext i8 %68 to i32
%70 = and i32 %69, 15
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds [16 x i8], [16 x i8]* %6, i64 0, i64 %71
%73 = load i8, i8* %72
%74 = zext i8 %73 to i32
%75 = or i32 %63, %74
%76 = trunc i32 %75 to i8
%77 = load i8*, i8** %3
%78 = load i8, i8* %7
%79 = zext i8 %78 to i64
%80 = getelementptr inbounds i8, i8* %77, i64 %79
store i8 %76, i8* %80
br label %81
81: ; preds = %49
%82 = load i8, i8* %7
%83 = zext i8 %82 to i32
%84 = icmp sgt i32 %83, 0
br i1 %84, label %49, label %85
85: ; preds = %81
store i8 0, i8* %7
br label %86
86: ; preds = %94, %85
%87 = load i8, i8* %7
%88 = zext i8 %87 to i32
%89 = icmp slt i32 %88, 8
br i1 %89, label %90, label %97
90: ; preds = %86
%91 = load i8, i8* %7
%92 = zext i8 %91 to i64
%93 = getelementptr inbounds [8 x i8], [8 x i8]* %13, i64 0, i64 %92
store i8 0, i8* %93
br label %94
94: ; preds = %90
%95 = load i8, i8* %7
%96 = add i8 %95, 1
store i8 %96, i8* %7
br label %86
97: ; preds = %86
store i8 0, i8* %7
br label %98
98: ; preds = %149, %97
%99 = load i8, i8* %7
%100 = zext i8 %99 to i32
%101 = icmp slt i32 %100, 64
br i1 %101, label %102, label %152
102: ; preds = %98
%103 = load i8, i8* %7
%104 = zext i8 %103 to i32
%105 = mul nsw i32 16, %104
%106 = srem i32 %105, 63
%107 = trunc i32 %106 to i8
store i8 %107, i8* %8
%108 = load i8, i8* %7
%109 = zext i8 %108 to i32
%110 = icmp eq i32 %109, 63
br i1 %110, label %111, label %112
111: ; preds = %102
store i8 63, i8* %8
br label %112
112: ; preds = %111, %102
%113 = load i8, i8* %7
%114 = zext i8 %113 to i32
%115 = sdiv i32 %114, 8
%116 = trunc i32 %115 to i8
store i8 %116, i8* %9
%117 = load i8, i8* %7
%118 = zext i8 %117 to i32
%119 = srem i32 %118, 8
%120 = trunc i32 %119 to i8
store i8 %120, i8* %10
%121 = load i8, i8* %8
%122 = zext i8 %121 to i32
%123 = sdiv i32 %122, 8
%124 = trunc i32 %123 to i8
store i8 %124, i8* %11
%125 = load i8, i8* %8
%126 = zext i8 %125 to i32
%127 = srem i32 %126, 8
%128 = trunc i32 %127 to i8
store i8 %128, i8* %12
%129 = load i8*, i8** %3
%130 = load i8, i8* %9
%131 = zext i8 %130 to i64
%132 = getelementptr inbounds i8, i8* %129, i64 %131
%133 = load i8, i8* %132
%134 = zext i8 %133 to i32
%135 = load i8, i8* %10
%136 = zext i8 %135 to i32
%137 = ashr i32 %134, %136
%138 = and i32 %137, 1
%139 = load i8, i8* %12
%140 = zext i8 %139 to i32
%141 = shl i32 %138, %140
%142 = load i8, i8* %11
%143 = zext i8 %142 to i64
%144 = getelementptr inbounds [8 x i8], [8 x i8]* %13, i64 0, i64 %143
%145 = load i8, i8* %144
%146 = zext i8 %145 to i32
%147 = or i32 %146, %141
%148 = trunc i32 %147 to i8
store i8 %148, i8* %144
br label %149
149: ; preds = %112
%150 = load i8, i8* %7
%151 = add i8 %150, 1
store i8 %151, i8* %7
br label %98
152: ; preds = %98
store i8 0, i8* %7
br label %153
153: ; preds = %166, %152
%154 = load i8, i8* %7
%155 = zext i8 %154 to i32
%156 = icmp sle i32 %155, 7
br i1 %156, label %157, label %169
157: ; preds = %153
%158 = load i8, i8* %7
%159 = zext i8 %158 to i64
%160 = getelementptr inbounds [8 x i8], [8 x i8]* %13, i64 0, i64 %159
%161 = load i8, i8* %160
%162 = load i8*, i8** %3
%163 = load i8, i8* %7
%164 = zext i8 %163 to i64
%165 = getelementptr inbounds i8, i8* %162, i64 %164
store i8 %161, i8* %165
br label %166
166: ; preds = %157
%167 = load i8, i8* %7
%168 = add i8 %167, 1
store i8 %168, i8* %7
br label %153
169: ; preds = %153
%170 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 0
%171 = load i8, i8* %170
store i8 %171, i8* %15
%172 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 1
%173 = load i8, i8* %172
store i8 %173, i8* %16
store i8 0, i8* %7
br label %174
174: ; preds = %186, %169
%175 = load i8, i8* %7
%176 = zext i8 %175 to i32
%177 = add nsw i32 %176, 2
%178 = sext i32 %177 to i64
%179 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 %178
%180 = load i8, i8* %179
%181 = load i8, i8* %7
%182 = zext i8 %181 to i64
%183 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 %182
store i8 %180, i8* %183
%184 = load i8, i8* %7
%185 = add i8 %184, 1
store i8 %185, i8* %7
br label %186
186: ; preds = %174
%187 = load i8, i8* %7
%188 = zext i8 %187 to i32
%189 = icmp slt i32 %188, 8
br i1 %189, label %174, label %190
190: ; preds = %186
%191 = load i8, i8* %15
%192 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 8
store i8 %191, i8* %192
%193 = load i8, i8* %16
%194 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 9
store i8 %193, i8* %194
store i8 0, i8* %7
%195 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 0
%196 = load i8, i8* %195
%197 = zext i8 %196 to i32
%198 = and i32 %197, 7
%199 = trunc i32 %198 to i8
store i8 %199, i8* %15
br label %200
200: ; preds = %222, %190
%201 = load i8, i8* %7
%202 = zext i8 %201 to i64
%203 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 %202
%204 = load i8, i8* %203
%205 = zext i8 %204 to i32
%206 = ashr i32 %205, 3
%207 = load i8, i8* %7
%208 = zext i8 %207 to i32
%209 = add nsw i32 %208, 1
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 %210
%212 = load i8, i8* %211
%213 = zext i8 %212 to i32
%214 = shl i32 %213, 5
%215 = or i32 %206, %214
%216 = trunc i32 %215 to i8
%217 = load i8, i8* %7
%218 = zext i8 %217 to i64
%219 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 %218
store i8 %216, i8* %219
%220 = load i8, i8* %7
%221 = add i8 %220, 1
store i8 %221, i8* %7
br label %222
222: ; preds = %200
%223 = load i8, i8* %7
%224 = zext i8 %223 to i32
%225 = icmp slt i32 %224, 9
br i1 %225, label %200, label %226
226: ; preds = %222
%227 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 9
%228 = load i8, i8* %227
%229 = zext i8 %228 to i32
%230 = ashr i32 %229, 3
%231 = load i8, i8* %15
%232 = zext i8 %231 to i32
%233 = shl i32 %232, 5
%234 = or i32 %230, %233
%235 = trunc i32 %234 to i8
%236 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 9
store i8 %235, i8* %236
%237 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 9
%238 = load i8, i8* %237
%239 = zext i8 %238 to i32
%240 = ashr i32 %239, 4
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds [16 x i8], [16 x i8]* %6, i64 0, i64 %241
%243 = load i8, i8* %242
%244 = zext i8 %243 to i32
%245 = shl i32 %244, 4
%246 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 9
%247 = load i8, i8* %246
%248 = zext i8 %247 to i32
%249 = and i32 %248, 15
%250 = or i32 %245, %249
%251 = trunc i32 %250 to i8
%252 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 9
store i8 %251, i8* %252
%253 = load i8, i8* %14
%254 = zext i8 %253 to i32
%255 = add nsw i32 %254, 1
%256 = srem i32 %255, 2
%257 = icmp eq i32 %256, 1
br i1 %257, label %258, label %264
258: ; preds = %226
%259 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 1
%260 = load i8, i8* %259
%261 = zext i8 %260 to i32
%262 = xor i32 %261, 128
%263 = trunc i32 %262 to i8
store i8 %263, i8* %259
br label %264
264: ; preds = %258, %226
%265 = load i8, i8* %14
%266 = zext i8 %265 to i32
%267 = add nsw i32 %266, 1
%268 = ashr i32 %267, 1
%269 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 2
%270 = load i8, i8* %269
%271 = zext i8 %270 to i32
%272 = and i32 %271, 15
%273 = xor i32 %268, %272
%274 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 2
%275 = load i8, i8* %274
%276 = zext i8 %275 to i32
%277 = and i32 %276, 240
%278 = or i32 %273, %277
%279 = trunc i32 %278 to i8
%280 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 2
store i8 %279, i8* %280
%281 = load i8, i8* %14
%282 = add i8 %281, 1
store i8 %282, i8* %14
br label %283
283: ; preds = %264
%284 = load i8, i8* %14
%285 = zext i8 %284 to i32
%286 = icmp slt i32 %285, 31
br i1 %286, label %21, label %287
287: ; preds = %283
store i8 0, i8* %7
br label %288
288: ; preds = %310, %287
%289 = load i8*, i8** %3
%290 = load i8, i8* %7
%291 = zext i8 %290 to i64
%292 = getelementptr inbounds i8, i8* %289, i64 %291
%293 = load i8, i8* %292
%294 = zext i8 %293 to i32
%295 = load i8, i8* %7
%296 = zext i8 %295 to i32
%297 = add nsw i32 %296, 2
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds [10 x i8], [10 x i8]* %5, i64 0, i64 %298
%300 = load i8, i8* %299
%301 = zext i8 %300 to i32
%302 = xor i32 %294, %301
%303 = trunc i32 %302 to i8
%304 = load i8*, i8** %3
%305 = load i8, i8* %7
%306 = zext i8 %305 to i64
%307 = getelementptr inbounds i8, i8* %304, i64 %306
store i8 %303, i8* %307
%308 = load i8, i8* %7
%309 = add i8 %308, 1
store i8 %309, i8* %7
br label %310
310: ; preds = %288
%311 = load i8, i8* %7
%312 = zext i8 %311 to i32
%313 = icmp sle i32 %312, 7
br i1 %313, label %288, label %314
314: ; preds = %310
ret i32 0
}

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