#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 *, unsigned int);
void gf_mul(unsigned char *a, const unsigned char *x, const unsigned char *y) {
  int i;
  int j;
  unsigned int xlen = 16;
  unsigned char prodbits[256];
  memcpy(a, x, xlen);
  for (i = 0; i < 256; ++i)
    prodbits[i] = 0;
  for (i = 0; i < 128; ++i)
    for (j = 0; j < 128; ++j)
      prodbits[i + j] ^=
          ((a[i / 8] >> (7 - (i % 8))) & 1) & ((y[j / 8] >> (7 - (j % 8))) & 1);
  for (i = 127; i >= 0; --i) {
    prodbits[i] ^= prodbits[i + 128];
    prodbits[i + 1] ^= prodbits[i + 128];
    prodbits[i + 2] ^= prodbits[i + 128];
    prodbits[i + 7] ^= prodbits[i + 128];
    prodbits[i + 128] ^= prodbits[i + 128];
  }
  for (i = 0; i < 16; ++i)
    a[i] = 0;
  for (i = 0; i < 128; ++i)
    a[i / 8] |= (prodbits[i] << (7 - (i % 8)));
}


x86 assembly (clang, -O0):
<gf_mul>:
push   %rbp
mov    %rsp,%rbp
sub    $0x160,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x10,-0x24(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x24(%rbp),%edx
call   1030 <memcpy@plt>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x100,-0x1c(%rbp)
jge    116c <gf_mul+0x5c>
movslq -0x1c(%rbp),%rax
movb   $0x0,-0x130(%rbp,%rax,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1145 <gf_mul+0x35>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x80,-0x1c(%rbp)
jge    1270 <gf_mul+0x160>
movl   $0x0,-0x20(%rbp)
cmpl   $0x80,-0x20(%rbp)
jge    125d <gf_mul+0x14d>
mov    -0x8(%rbp),%rax
mov    %rax,-0x150(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x150(%rbp),%rax
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x144(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    -0x144(%rbp),%eax
mov    $0x7,%ecx
sub    %edx,%ecx
sar    %cl,%eax
and    $0x1,%eax
mov    %eax,-0x134(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x140(%rbp)
mov    -0x20(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x140(%rbp),%rax
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%eax
mov    %eax,-0x138(%rbp)
mov    -0x20(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    -0x138(%rbp),%eax
mov    %edx,%esi
mov    -0x134(%rbp),%edx
mov    $0x7,%ecx
sub    %esi,%ecx
sar    %cl,%eax
and    $0x1,%eax
and    %eax,%edx
mov    -0x1c(%rbp),%eax
add    -0x20(%rbp),%eax
cltq
movzbl -0x130(%rbp,%rax,1),%ecx
ff
xor    %edx,%ecx
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1187 <gf_mul+0x77>
jmp    1262 <gf_mul+0x152>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1173 <gf_mul+0x63>
movl   $0x7f,-0x1c(%rbp)
cmpl   $0x0,-0x1c(%rbp)
jl     1364 <gf_mul+0x254>
mov    -0x1c(%rbp),%eax
add    $0x80,%eax
cltq
movzbl -0x130(%rbp,%rax,1),%edx
ff
movslq -0x1c(%rbp),%rax
movzbl -0x130(%rbp,%rax,1),%ecx
ff
xor    %edx,%ecx
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x1c(%rbp),%eax
add    $0x80,%eax
cltq
movzbl -0x130(%rbp,%rax,1),%edx
ff
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
cltq
movzbl -0x130(%rbp,%rax,1),%ecx
ff
xor    %edx,%ecx
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x1c(%rbp),%eax
add    $0x80,%eax
cltq
movzbl -0x130(%rbp,%rax,1),%edx
ff
mov    -0x1c(%rbp),%eax
add    $0x2,%eax
cltq
movzbl -0x130(%rbp,%rax,1),%ecx
ff
xor    %edx,%ecx
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x1c(%rbp),%eax
add    $0x80,%eax
cltq
movzbl -0x130(%rbp,%rax,1),%edx
ff
mov    -0x1c(%rbp),%eax
add    $0x7,%eax
cltq
movzbl -0x130(%rbp,%rax,1),%ecx
ff
xor    %edx,%ecx
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x1c(%rbp),%eax
add    $0x80,%eax
cltq
movzbl -0x130(%rbp,%rax,1),%edx
ff
mov    -0x1c(%rbp),%eax
add    $0x80,%eax
cltq
movzbl -0x130(%rbp,%rax,1),%ecx
ff
xor    %edx,%ecx
mov    %cl,-0x130(%rbp,%rax,1)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
jmp    1277 <gf_mul+0x167>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x10,-0x1c(%rbp)
jge    138f <gf_mul+0x27f>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    136b <gf_mul+0x25b>
movl   $0x0,-0x1c(%rbp)
cmpl   $0x80,-0x1c(%rbp)
jge    13fc <gf_mul+0x2ec>
movslq -0x1c(%rbp),%rax
movzbl -0x130(%rbp,%rax,1),%esi
ff
mov    -0x1c(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    $0x7,%ecx
sub    %edx,%ecx
shl    %cl,%esi
mov    -0x8(%rbp),%rax
mov    %rax,-0x158(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x8,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x158(%rbp),%rax
movslq %ecx,%rcx
movzbl (%rax,%rcx,1),%edx
or     %esi,%edx
mov    %dl,(%rax,%rcx,1)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1396 <gf_mul+0x286>
add    $0x160,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<gf_mul>:
push   %r15
push   %r14
push   %rbx
sub    $0x100,%rsp
mov    %rdx,%r15
mov    %rdi,%r14
mov    $0x10,%edx
call   1030 <memcpy@plt>
xorps  %xmm0,%xmm0
movaps %xmm0,(%rsp)
movaps %xmm0,0x10(%rsp)
movaps %xmm0,0x20(%rsp)
movaps %xmm0,0x30(%rsp)
movaps %xmm0,0x40(%rsp)
movaps %xmm0,0x50(%rsp)
movaps %xmm0,0x60(%rsp)
movaps %xmm0,0x70(%rsp)
movaps %xmm0,0x80(%rsp)
movaps %xmm0,0x90(%rsp)
movaps %xmm0,0xa0(%rsp)
movaps %xmm0,0xb0(%rsp)
movaps %xmm0,0xc0(%rsp)
movaps %xmm0,0xd0(%rsp)
movaps %xmm0,0xe0(%rsp)
movaps %xmm0,0xf0(%rsp)
lea    0x1(%rsp),%r9
xor    %r8d,%r8d
xchg   %ax,%ax
mov    %r8d,%ecx
not    %cl
mov    %r8d,%eax
shr    $0x3,%eax
mov    (%r14,%rax,1),%bl
and    $0x7,%cl
shr    %cl,%bl
and    $0x1,%bl
xor    %edi,%edi
nopl   0x0(%rax)
mov    %edi,%esi
shr    $0x3,%esi
movzbl (%r15,%rsi,1),%edx
mov    %edi,%eax
and    $0x6,%al
mov    %eax,%ecx
xor    $0x7,%cl
shr    %cl,%dl
and    %bl,%dl
xor    %dl,-0x1(%r9,%rdi,1)
movzbl (%r15,%rsi,1),%edx
xor    $0x6,%al
mov    %eax,%ecx
shr    %cl,%dl
and    %bl,%dl
xor    %dl,(%r9,%rdi,1)
add    $0x2,%rdi
cmp    $0x80,%rdi
jne    11c0 <gf_mul+0xb0>
add    $0x1,%r8
add    $0x1,%r9
cmp    $0x80,%r8
jne    11a0 <gf_mul+0x90>
mov    0x80(%rsp),%al
mov    0x81(%rsp),%dl
mov    $0x7f,%ecx
xchg   %ax,%ax
movzbl 0x80(%rsp,%rcx,1),%ebx
movzbl (%rsp,%rcx,1),%esi
xor    %bl,%sil
mov    %sil,(%rsp,%rcx,1)
xor    %bl,%al
mov    %al,0x1(%rsp,%rcx,1)
xor    %bl,%dl
mov    %dl,0x2(%rsp,%rcx,1)
xor    %bl,0x7(%rsp,%rcx,1)
movb   $0x0,0x80(%rsp,%rcx,1)
mov    %eax,%edx
mov    %esi,%eax
add    $0xffffffffffffffff,%rcx
jb     1220 <gf_mul+0x110>
xorps  %xmm0,%xmm0
movups %xmm0,(%r14)
xor    %edx,%edx
xchg   %ax,%ax
movzbl (%rsp,%rdx,1),%edi
mov    %edx,%eax
and    $0x6,%al
mov    %eax,%ecx
xor    $0x7,%cl
shl    %cl,%dil
mov    %edx,%esi
shr    $0x3,%esi
or     (%r14,%rsi,1),%dil
mov    %dil,(%r14,%rsi,1)
movzbl 0x1(%rsp,%rdx,1),%ebx
xor    $0x6,%al
mov    %eax,%ecx
shl    %cl,%bl
or     %dil,%bl
mov    %bl,(%r14,%rsi,1)
add    $0x2,%rdx
cmp    $0x80,%rdx
jne    1260 <gf_mul+0x150>
add    $0x100,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define void @gf_mul(i8* %0, i8* %1, i8* %2) {
%4 = alloca i8*
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca [256 x i8]
store i8* %0, i8** %4
store i8* %1, i8** %5
store i8* %2, i8** %6
store i32 16, i32* %9
%11 = load i8*, i8** %4
%12 = load i8*, i8** %5
%13 = load i32, i32* %9
%14 = call i32 @memcpy(i8* %11, i8* %12, i32 %13)
store i32 0, i32* %7
br label %15
15: ; preds = %22, %3
%16 = load i32, i32* %7
%17 = icmp slt i32 %16, 256
br i1 %17, label %18, label %25
18: ; preds = %15
%19 = load i32, i32* %7
%20 = sext i32 %19 to i64
%21 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 %20
store i8 0, i8* %21
br label %22
22: ; preds = %18
%23 = load i32, i32* %7
%24 = add nsw i32 %23, 1
store i32 %24, i32* %7
br label %15
25: ; preds = %15
store i32 0, i32* %7
br label %26
26: ; preds = %72, %25
%27 = load i32, i32* %7
%28 = icmp slt i32 %27, 128
br i1 %28, label %29, label %75
29: ; preds = %26
store i32 0, i32* %8
br label %30
30: ; preds = %68, %29
%31 = load i32, i32* %8
%32 = icmp slt i32 %31, 128
br i1 %32, label %33, label %71
33: ; preds = %30
%34 = load i8*, i8** %4
%35 = load i32, i32* %7
%36 = sdiv i32 %35, 8
%37 = sext i32 %36 to i64
%38 = getelementptr inbounds i8, i8* %34, i64 %37
%39 = load i8, i8* %38
%40 = zext i8 %39 to i32
%41 = load i32, i32* %7
%42 = srem i32 %41, 8
%43 = sub nsw i32 7, %42
%44 = ashr i32 %40, %43
%45 = and i32 %44, 1
%46 = load i8*, i8** %6
%47 = load i32, i32* %8
%48 = sdiv i32 %47, 8
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i8, i8* %46, i64 %49
%51 = load i8, i8* %50
%52 = zext i8 %51 to i32
%53 = load i32, i32* %8
%54 = srem i32 %53, 8
%55 = sub nsw i32 7, %54
%56 = ashr i32 %52, %55
%57 = and i32 %56, 1
%58 = and i32 %45, %57
%59 = load i32, i32* %7
%60 = load i32, i32* %8
%61 = add nsw i32 %59, %60
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 %62
%64 = load i8, i8* %63
%65 = zext i8 %64 to i32
%66 = xor i32 %65, %58
%67 = trunc i32 %66 to i8
store i8 %67, i8* %63
br label %68
68: ; preds = %33
%69 = load i32, i32* %8
%70 = add nsw i32 %69, 1
store i32 %70, i32* %8
br label %30
71: ; preds = %30
br label %72
72: ; preds = %71
%73 = load i32, i32* %7
%74 = add nsw i32 %73, 1
store i32 %74, i32* %7
br label %26
75: ; preds = %26
store i32 127, i32* %7
br label %76
76: ; preds = %149, %75
%77 = load i32, i32* %7
%78 = icmp sge i32 %77, 0
br i1 %78, label %79, label %152
79: ; preds = %76
%80 = load i32, i32* %7
%81 = add nsw i32 %80, 128
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 %82
%84 = load i8, i8* %83
%85 = zext i8 %84 to i32
%86 = load i32, i32* %7
%87 = sext i32 %86 to i64
%88 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 %87
%89 = load i8, i8* %88
%90 = zext i8 %89 to i32
%91 = xor i32 %90, %85
%92 = trunc i32 %91 to i8
store i8 %92, i8* %88
%93 = load i32, i32* %7
%94 = add nsw i32 %93, 128
%95 = sext i32 %94 to i64
%96 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 %95
%97 = load i8, i8* %96
%98 = zext i8 %97 to i32
%99 = load i32, i32* %7
%100 = add nsw i32 %99, 1
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 %101
%103 = load i8, i8* %102
%104 = zext i8 %103 to i32
%105 = xor i32 %104, %98
%106 = trunc i32 %105 to i8
store i8 %106, i8* %102
%107 = load i32, i32* %7
%108 = add nsw i32 %107, 128
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 %109
%111 = load i8, i8* %110
%112 = zext i8 %111 to i32
%113 = load i32, i32* %7
%114 = add nsw i32 %113, 2
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 %115
%117 = load i8, i8* %116
%118 = zext i8 %117 to i32
%119 = xor i32 %118, %112
%120 = trunc i32 %119 to i8
store i8 %120, i8* %116
%121 = load i32, i32* %7
%122 = add nsw i32 %121, 128
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 %123
%125 = load i8, i8* %124
%126 = zext i8 %125 to i32
%127 = load i32, i32* %7
%128 = add nsw i32 %127, 7
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 %129
%131 = load i8, i8* %130
%132 = zext i8 %131 to i32
%133 = xor i32 %132, %126
%134 = trunc i32 %133 to i8
store i8 %134, i8* %130
%135 = load i32, i32* %7
%136 = add nsw i32 %135, 128
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 %137
%139 = load i8, i8* %138
%140 = zext i8 %139 to i32
%141 = load i32, i32* %7
%142 = add nsw i32 %141, 128
%143 = sext i32 %142 to i64
%144 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 %143
%145 = load i8, i8* %144
%146 = zext i8 %145 to i32
%147 = xor i32 %146, %140
%148 = trunc i32 %147 to i8
store i8 %148, i8* %144
br label %149
149: ; preds = %79
%150 = load i32, i32* %7
%151 = add nsw i32 %150, -1
store i32 %151, i32* %7
br label %76
152: ; preds = %76
store i32 0, i32* %7
br label %153
153: ; preds = %161, %152
%154 = load i32, i32* %7
%155 = icmp slt i32 %154, 16
br i1 %155, label %156, label %164
156: ; preds = %153
%157 = load i8*, i8** %4
%158 = load i32, i32* %7
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds i8, i8* %157, i64 %159
store i8 0, i8* %160
br label %161
161: ; preds = %156
%162 = load i32, i32* %7
%163 = add nsw i32 %162, 1
store i32 %163, i32* %7
br label %153
164: ; preds = %153
store i32 0, i32* %7
br label %165
165: ; preds = %187, %164
%166 = load i32, i32* %7
%167 = icmp slt i32 %166, 128
br i1 %167, label %168, label %190
168: ; preds = %165
%169 = load i32, i32* %7
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds [256 x i8], [256 x i8]* %10, i64 0, i64 %170
%172 = load i8, i8* %171
%173 = zext i8 %172 to i32
%174 = load i32, i32* %7
%175 = srem i32 %174, 8
%176 = sub nsw i32 7, %175
%177 = shl i32 %173, %176
%178 = load i8*, i8** %4
%179 = load i32, i32* %7
%180 = sdiv i32 %179, 8
%181 = sext i32 %180 to i64
%182 = getelementptr inbounds i8, i8* %178, i64 %181
%183 = load i8, i8* %182
%184 = zext i8 %183 to i32
%185 = or i32 %184, %177
%186 = trunc i32 %185 to i8
store i8 %186, i8* %182
br label %187
187: ; preds = %168
%188 = load i32, i32* %7
%189 = add nsw i32 %188, 1
store i32 %189, i32* %7
br label %165
190: ; preds = %165
ret void
}

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