#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 */
typedef int /*<<< orphan*/ tab;

/* Variables and functions */
int /*<<< orphan*/ shuffle(unsigned char *, int);
size_t strlen(char *);
unsigned long pearson64(unsigned char *str) {
  static unsigned char tab[256];
  static unsigned char init;
  unsigned char h, hh[8];
  unsigned long v;
  size_t i, j, len;
  if (!init) {
    shuffle(tab, (sizeof(tab) / sizeof(tab[0])));
    init = 1;
  }
  len = strlen((char *)str);
  for (i = 0; i < 8; i++) {
    h = tab[(str[0] + i) % 256];
    for (j = 1; j < len; j++)
      h = tab[h ^ str[j]];
    hh[i] = h;
  }
  v = 0;
  for (i = 0; i < 8; i++)
    v |= ((unsigned long)hh[i]) << (8 * i);
  return v;
}


x86 assembly (clang, -O0):
<pearson64>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
cmpb   $0x0,0x300d(%rip)
jne    1151 <pearson64+0x31>
lea    0x2f00(%rip),%rdi
mov    $0x100,%esi
call   1030 <shuffle@plt>
movb   $0x1,0x2fef(%rip)
mov    -0x8(%rbp),%rdi
call   1040 <strlen@plt>
mov    %rax,-0x38(%rbp)
movq   $0x0,-0x28(%rbp)
cmpq   $0x8,-0x28(%rbp)
jae    11f7 <pearson64+0xd7>
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
mov    %eax,%ecx
add    -0x28(%rbp),%rcx
and    $0xff,%rcx
lea    0x2eb4(%rip),%rax
mov    (%rax,%rcx,1),%al
mov    %al,-0x9(%rbp)
movq   $0x1,-0x30(%rbp)
mov    -0x30(%rbp),%rax
cmp    -0x38(%rbp),%rax
jae    11db <pearson64+0xbb>
movzbl -0x9(%rbp),%eax
mov    -0x8(%rbp),%rcx
mov    -0x30(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
xor    %ecx,%eax
movslq %eax,%rcx
lea    0x2e7c(%rip),%rax
mov    (%rax,%rcx,1),%al
mov    %al,-0x9(%rbp)
mov    -0x30(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
jmp    119a <pearson64+0x7a>
mov    -0x9(%rbp),%cl
mov    -0x28(%rbp),%rax
mov    %cl,-0x11(%rbp,%rax,1)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1166 <pearson64+0x46>
movq   $0x0,-0x20(%rbp)
movq   $0x0,-0x28(%rbp)
cmpq   $0x8,-0x28(%rbp)
jae    123f <pearson64+0x11f>
mov    -0x28(%rbp),%rax
movzbl -0x11(%rbp,%rax,1),%eax
mov    -0x28(%rbp),%rcx
shl    $0x3,%rcx
shl    %cl,%rax
or     -0x20(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
jmp    1207 <pearson64+0xe7>
mov    -0x20(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<pearson64>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x18,%rsp
mov    %rdi,%r13
cmpb   $0x0,0x3008(%rip)
jne    1152 <pearson64+0x32>
lea    0x2eff(%rip),%rdi
mov    $0x100,%esi
call   1030 <shuffle@plt>
movb   $0x1,0x2fee(%rip)
mov    %r13,%rdi
call   1040 <strlen@plt>
movzbl 0x0(%r13),%r10d
lea    0x2eda(%rip),%r12
mov    (%r10,%r12,1),%cl
cmp    $0x2,%rax
jb     1193 <pearson64+0x73>
lea    -0x1(%rax),%r15
lea    -0x2(%rax),%r14
mov    %r15d,%edx
and    $0x3,%edx
cmp    $0x3,%r14
jae    11a3 <pearson64+0x83>
mov    $0x1,%ebp
test   %rdx,%rdx
jne    11f6 <pearson64+0xd6>
jmp    1215 <pearson64+0xf5>
lea    0x1(%r10),%eax
movzbl %al,%eax
mov    (%rax,%r12,1),%r9b
jmp    1249 <pearson64+0x129>
mov    %r15,%rdi
and    $0xfffffffffffffffc,%rdi
xor    %ebp,%ebp
nopl   0x0(%rax)
xor    0x1(%r13,%rbp,1),%cl
movzbl %cl,%ecx
movzbl 0x2(%r13,%rbp,1),%ebx
xor    (%rcx,%r12,1),%bl
movzbl 0x3(%r13,%rbp,1),%ecx
movzbl %bl,%esi
xor    (%rsi,%r12,1),%cl
movzbl %cl,%ecx
movzbl 0x4(%r13,%rbp,1),%ebx
xor    (%rcx,%r12,1),%bl
movzbl %bl,%ecx
movzbl (%rcx,%r12,1),%ecx
add    $0x4,%rbp
cmp    %rbp,%rdi
jne    11b0 <pearson64+0x90>
add    $0x1,%rbp
test   %rdx,%rdx
je     1215 <pearson64+0xf5>
add    %r13,%rbp
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
xor    0x0(%rbp,%rsi,1),%cl
movzbl %cl,%ecx
movzbl (%rcx,%r12,1),%ecx
add    $0x1,%rsi
cmp    %rsi,%rdx
jne    1200 <pearson64+0xe0>
lea    0x1(%r10),%edx
movzbl %dl,%edx
mov    (%rdx,%r12,1),%r9b
cmp    $0x2,%rax
jb     1249 <pearson64+0x129>
mov    %r15d,%ebp
and    $0x3,%ebp
cmp    $0x3,%r14
jae    12eb <pearson64+0x1cb>
mov    $0x1,%edi
test   %rbp,%rbp
jne    1347 <pearson64+0x227>
jmp    1366 <pearson64+0x246>
lea    0x2(%r10),%eax
movzbl %al,%eax
mov    (%rax,%r12,1),%r8b
lea    0x3(%r10),%eax
movzbl %al,%eax
mov    (%rax,%r12,1),%r11b
lea    0x4(%r10),%eax
movzbl %al,%eax
mov    (%rax,%r12,1),%bpl
lea    0x5(%r10),%eax
movzbl %al,%eax
mov    (%rax,%r12,1),%r14b
lea    0x6(%r10),%eax
movzbl %al,%eax
mov    (%rax,%r12,1),%r15b
add    $0x7,%r10d
movzbl %r10b,%eax
mov    (%rax,%r12,1),%dil
movzbl %cl,%eax
movzbl %r9b,%ecx
shl    $0x8,%rcx
or     %rax,%rcx
movzbl %r8b,%eax
shl    $0x10,%rax
or     %rcx,%rax
movzbl %r11b,%ecx
shl    $0x18,%rcx
or     %rax,%rcx
movzbl %bpl,%eax
shl    $0x20,%rax
or     %rcx,%rax
movzbl %r14b,%ecx
shl    $0x28,%rcx
or     %rax,%rcx
movzbl %r15b,%edx
shl    $0x30,%rdx
or     %rcx,%rdx
movzbl %dil,%eax
shl    $0x38,%rax
or     %rdx,%rax
add    $0x18,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r15,%rsi
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    0x1(%r13,%rdi,1),%r9b
movzbl %r9b,%edx
movzbl 0x2(%r13,%rdi,1),%ebx
xor    (%rdx,%r12,1),%bl
movzbl 0x3(%r13,%rdi,1),%edx
movzbl %bl,%ebx
xor    (%rbx,%r12,1),%dl
movzbl %dl,%edx
movzbl 0x4(%r13,%rdi,1),%ebx
xor    (%rdx,%r12,1),%bl
movzbl %bl,%edx
movzbl (%rdx,%r12,1),%r9d
add    $0x4,%rdi
cmp    %rdi,%rsi
jne    1300 <pearson64+0x1e0>
add    $0x1,%rdi
test   %rbp,%rbp
je     1366 <pearson64+0x246>
add    %r13,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
xor    (%rdi,%rsi,1),%r9b
movzbl %r9b,%edx
movzbl (%rdx,%r12,1),%r9d
add    $0x1,%rsi
cmp    %rsi,%rbp
jne    1350 <pearson64+0x230>
lea    0x2(%r10),%esi
movzbl %sil,%esi
mov    (%rsi,%r12,1),%r8b
cmp    $0x2,%rax
jb     1254 <pearson64+0x134>
mov    %r15d,%ebp
and    $0x3,%ebp
cmp    $0x3,%r14
jae    1394 <pearson64+0x274>
mov    $0x1,%edi
test   %rbp,%rbp
jne    13e7 <pearson64+0x2c7>
jmp    1406 <pearson64+0x2e6>
mov    %r15,%rsi
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopl   (%rax)
xor    0x1(%r13,%rdi,1),%r8b
movzbl %r8b,%ebx
movzbl 0x2(%r13,%rdi,1),%edx
xor    (%rbx,%r12,1),%dl
movzbl 0x3(%r13,%rdi,1),%ebx
movzbl %dl,%edx
xor    (%rdx,%r12,1),%bl
movzbl %bl,%edx
movzbl 0x4(%r13,%rdi,1),%ebx
xor    (%rdx,%r12,1),%bl
movzbl %bl,%edx
movzbl (%rdx,%r12,1),%r8d
add    $0x4,%rdi
cmp    %rdi,%rsi
jne    13a0 <pearson64+0x280>
add    $0x1,%rdi
test   %rbp,%rbp
je     1406 <pearson64+0x2e6>
add    %r13,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
xor    (%rdi,%rsi,1),%r8b
movzbl %r8b,%edx
movzbl (%rdx,%r12,1),%r8d
add    $0x1,%rsi
cmp    %rsi,%rbp
jne    13f0 <pearson64+0x2d0>
lea    0x3(%r10),%edx
movzbl %dl,%edx
mov    (%rdx,%r12,1),%r11b
cmp    $0x2,%rax
jb     125f <pearson64+0x13f>
mov    %r15d,%ebp
and    $0x3,%ebp
cmp    $0x3,%r14
jae    142e <pearson64+0x30e>
mov    $0x1,%edi
jmp    1482 <pearson64+0x362>
mov    %r15,%rsi
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
xor    0x1(%r13,%rdi,1),%r11b
movzbl %r11b,%edx
movzbl 0x2(%r13,%rdi,1),%ebx
xor    (%rdx,%r12,1),%bl
movzbl 0x3(%r13,%rdi,1),%edx
movzbl %bl,%ebx
xor    (%rbx,%r12,1),%dl
movzbl %dl,%edx
movzbl 0x4(%r13,%rdi,1),%ebx
xor    (%rdx,%r12,1),%bl
movzbl %bl,%edx
movzbl (%rdx,%r12,1),%r11d
add    $0x4,%rdi
cmp    %rdi,%rsi
jne    1440 <pearson64+0x320>
add    $0x1,%rdi
test   %rbp,%rbp
je     14a6 <pearson64+0x386>
add    %r13,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
xor    (%rdi,%rsi,1),%r11b
movzbl %r11b,%edx
movzbl (%rdx,%r12,1),%r11d
add    $0x1,%rsi
cmp    %rsi,%rbp
jne    1490 <pearson64+0x370>
lea    0x4(%r10),%edx
movzbl %dl,%edx
mov    (%rdx,%r12,1),%bpl
cmp    $0x2,%rax
jb     126a <pearson64+0x14a>
mov    %r14,%rdx
mov    %r15d,%r14d
and    $0x3,%r14d
mov    %rdx,(%rsp)
cmp    $0x3,%rdx
jae    14d6 <pearson64+0x3b6>
mov    $0x1,%edi
jmp    1522 <pearson64+0x402>
mov    %r15,%rsi
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nop
xor    0x1(%r13,%rdi,1),%bpl
movzbl %bpl,%edx
movzbl 0x2(%r13,%rdi,1),%ebx
xor    (%rdx,%r12,1),%bl
movzbl 0x3(%r13,%rdi,1),%edx
movzbl %bl,%ebx
xor    (%rbx,%r12,1),%dl
movzbl %dl,%edx
movzbl 0x4(%r13,%rdi,1),%ebx
xor    (%rdx,%r12,1),%bl
movzbl %bl,%edx
movzbl (%rdx,%r12,1),%ebp
add    $0x4,%rdi
cmp    %rdi,%rsi
jne    14e0 <pearson64+0x3c0>
add    $0x1,%rdi
test   %r14,%r14
je     1546 <pearson64+0x426>
add    %r13,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
xor    (%rdi,%rsi,1),%bpl
movzbl %bpl,%edx
movzbl (%rdx,%r12,1),%ebp
add    $0x1,%rsi
cmp    %rsi,%r14
jne    1530 <pearson64+0x410>
lea    0x5(%r10),%edx
movzbl %dl,%edx
mov    (%rdx,%r12,1),%r14b
cmp    $0x2,%rax
jb     1275 <pearson64+0x155>
mov    %r15,%rsi
and    $0x3,%r15d
cmpq   $0x3,(%rsp)
mov    %rsi,0x8(%rsp)
jae    1575 <pearson64+0x455>
mov    $0x1,%edi
jmp    15c2 <pearson64+0x4a2>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
xor    0x1(%r13,%rdi,1),%r14b
movzbl %r14b,%edx
movzbl 0x2(%r13,%rdi,1),%ebx
xor    (%rdx,%r12,1),%bl
movzbl 0x3(%r13,%rdi,1),%edx
movzbl %bl,%ebx
xor    (%rbx,%r12,1),%dl
movzbl %dl,%edx
movzbl 0x4(%r13,%rdi,1),%ebx
xor    (%rdx,%r12,1),%bl
movzbl %bl,%edx
movzbl (%rdx,%r12,1),%r14d
add    $0x4,%rdi
cmp    %rdi,%rsi
jne    1580 <pearson64+0x460>
add    $0x1,%rdi
test   %r15,%r15
je     15e6 <pearson64+0x4c6>
add    %r13,%rdi
xor    %esi,%esi
nopl   0x0(%rax)
xor    (%rdi,%rsi,1),%r14b
movzbl %r14b,%edx
movzbl (%rdx,%r12,1),%r14d
add    $0x1,%rsi
cmp    %rsi,%r15
jne    15d0 <pearson64+0x4b0>
lea    0x6(%r10),%edx
movzbl %dl,%edx
mov    (%rdx,%r12,1),%r15b
cmp    $0x2,%rax
jb     1280 <pearson64+0x160>
mov    0x8(%rsp),%rsi
mov    %esi,%ebx
and    $0x3,%ebx
cmpq   $0x3,(%rsp)
jae    1613 <pearson64+0x4f3>
mov    $0x1,%edi
jmp    1665 <pearson64+0x545>
mov    %rbx,0x10(%rsp)
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
xor    0x1(%r13,%rdi,1),%r15b
movzbl %r15b,%edx
movzbl 0x2(%r13,%rdi,1),%ebx
xor    (%rdx,%r12,1),%bl
movzbl 0x3(%r13,%rdi,1),%edx
movzbl %bl,%ebx
xor    (%rbx,%r12,1),%dl
movzbl %dl,%edx
movzbl 0x4(%r13,%rdi,1),%ebx
xor    (%rdx,%r12,1),%bl
movzbl %bl,%edx
movzbl (%rdx,%r12,1),%r15d
add    $0x4,%rdi
cmp    %rdi,%rsi
jne    161e <pearson64+0x4fe>
add    $0x1,%rdi
mov    0x10(%rsp),%rbx
test   %rbx,%rbx
je     1685 <pearson64+0x565>
add    %r13,%rdi
xor    %esi,%esi
xor    (%rdi,%rsi,1),%r15b
movzbl %r15b,%edx
movzbl (%rdx,%r12,1),%r15d
add    $0x1,%rsi
cmp    %rsi,%rbx
jne    166f <pearson64+0x54f>
add    $0x7,%r10d
movzbl %r10b,%edx
mov    (%rdx,%r12,1),%dil
cmp    $0x2,%rax
jb     128c <pearson64+0x16c>
mov    0x8(%rsp),%rsi
mov    %esi,%r10d
and    $0x3,%r10d
cmpq   $0x3,(%rsp)
jae    16b5 <pearson64+0x595>
mov    $0x1,%eax
jmp    16fd <pearson64+0x5dd>
and    $0xfffffffffffffffc,%rsi
xor    %eax,%eax
xor    0x1(%r13,%rax,1),%dil
movzbl %dil,%edx
movzbl 0x2(%r13,%rax,1),%ebx
xor    (%rdx,%r12,1),%bl
movzbl 0x3(%r13,%rax,1),%edx
movzbl %bl,%edi
xor    (%rdi,%r12,1),%dl
movzbl %dl,%edx
movzbl 0x4(%r13,%rax,1),%ebx
xor    (%rdx,%r12,1),%bl
movzbl %bl,%edx
movzbl (%rdx,%r12,1),%edi
add    $0x4,%rax
cmp    %rax,%rsi
jne    16bb <pearson64+0x59b>
add    $0x1,%rax
test   %r10,%r10
je     128c <pearson64+0x16c>
add    %rax,%r13
xor    %eax,%eax
xor    0x0(%r13,%rax,1),%dil
movzbl %dil,%edx
movzbl (%rdx,%r12,1),%edi
add    $0x1,%rax
cmp    %rax,%r10
jne    170b <pearson64+0x5eb>
jmp    128c <pearson64+0x16c>

LLVM IR (-O0):
@pearson64.tab = internal global [256 x i8] zeroinitializer
@pearson64.init = internal global i8 0
define i64 @pearson64(i8* %0) {
%2 = alloca i8*
%3 = alloca i8
%4 = alloca [8 x i8]
%5 = alloca i64
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
store i8* %0, i8** %2
%9 = load i8, i8* @pearson64.init
%10 = icmp ne i8 %9, 0
br i1 %10, label %13, label %11
11: ; preds = %1
%12 = call i32 @shuffle(i8* getelementptr inbounds ([256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 0), i32 256)
store i8 1, i8* @pearson64.init
br label %13
13: ; preds = %11, %1
%14 = load i8*, i8** %2
%15 = call i64 @strlen(i8* %14)
store i64 %15, i64* %8
store i64 0, i64* %6
br label %16
16: ; preds = %52, %13
%17 = load i64, i64* %6
%18 = icmp ult i64 %17, 8
br i1 %18, label %19, label %55
19: ; preds = %16
%20 = load i8*, i8** %2
%21 = getelementptr inbounds i8, i8* %20, i64 0
%22 = load i8, i8* %21
%23 = zext i8 %22 to i64
%24 = load i64, i64* %6
%25 = add i64 %23, %24
%26 = urem i64 %25, 256
%27 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %26
%28 = load i8, i8* %27
store i8 %28, i8* %3
store i64 1, i64* %7
br label %29
29: ; preds = %45, %19
%30 = load i64, i64* %7
%31 = load i64, i64* %8
%32 = icmp ult i64 %30, %31
br i1 %32, label %33, label %48
33: ; preds = %29
%34 = load i8, i8* %3
%35 = zext i8 %34 to i32
%36 = load i8*, i8** %2
%37 = load i64, i64* %7
%38 = getelementptr inbounds i8, i8* %36, i64 %37
%39 = load i8, i8* %38
%40 = zext i8 %39 to i32
%41 = xor i32 %35, %40
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %42
%44 = load i8, i8* %43
store i8 %44, i8* %3
br label %45
45: ; preds = %33
%46 = load i64, i64* %7
%47 = add i64 %46, 1
store i64 %47, i64* %7
br label %29
48: ; preds = %29
%49 = load i8, i8* %3
%50 = load i64, i64* %6
%51 = getelementptr inbounds [8 x i8], [8 x i8]* %4, i64 0, i64 %50
store i8 %49, i8* %51
br label %52
52: ; preds = %48
%53 = load i64, i64* %6
%54 = add i64 %53, 1
store i64 %54, i64* %6
br label %16
55: ; preds = %16
store i64 0, i64* %5
store i64 0, i64* %6
br label %56
56: ; preds = %69, %55
%57 = load i64, i64* %6
%58 = icmp ult i64 %57, 8
br i1 %58, label %59, label %72
59: ; preds = %56
%60 = load i64, i64* %6
%61 = getelementptr inbounds [8 x i8], [8 x i8]* %4, i64 0, i64 %60
%62 = load i8, i8* %61
%63 = zext i8 %62 to i64
%64 = load i64, i64* %6
%65 = mul i64 8, %64
%66 = shl i64 %63, %65
%67 = load i64, i64* %5
%68 = or i64 %67, %66
store i64 %68, i64* %5
br label %69
69: ; preds = %59
%70 = load i64, i64* %6
%71 = add i64 %70, 1
store i64 %71, i64* %6
br label %56
72: ; preds = %56
%73 = load i64, i64* %5
ret i64 %73
}

LLVM IR (-O2):
@pearson64.tab = internal global [256 x i8] zeroinitializer
@pearson64.init = internal unnamed_addr global i1 false
define i64 @pearson64(i8* nocapture %0) {
%2 = load i1, i1* @pearson64.init
br i1 %2, label %5, label %3
3: ; preds = %1
%4 = tail call i32 @shuffle(i8* getelementptr inbounds ([256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 0), i32 256)
store i1 true, i1* @pearson64.init
br label %5
5: ; preds = %3, %1
%6 = tail call i64 @strlen(i8* dereferenceable(1) %0)
%7 = load i8, i8* %0
%8 = zext i8 %7 to i64
%9 = icmp ugt i64 %6, 1
%10 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %8
%11 = load i8, i8* %10
br i1 %9, label %12, label %19
12: ; preds = %5
%13 = add i64 %6, -1
%14 = add i64 %6, -2
%15 = and i64 %13, 3
%16 = icmp ult i64 %14, 3
br i1 %16, label %58, label %17
17: ; preds = %12
%18 = and i64 %13, -4
br label %24
19: ; preds = %5
%20 = add nuw nsw i64 %8, 1
%21 = and i64 %20, 255
%22 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %21
%23 = load i8, i8* %22
br label %121
24: ; preds = %24, %17
%25 = phi i8 [ %11, %17 ], [ %55, %24 ]
%26 = phi i64 [ 1, %17 ], [ %53, %24 ]
%27 = phi i64 [ 0, %17 ], [ %56, %24 ]
%28 = getelementptr inbounds i8, i8* %0, i64 %26
%29 = load i8, i8* %28
%30 = xor i8 %29, %25
%31 = zext i8 %30 to i64
%32 = add nuw nsw i64 %26, 1
%33 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %31
%34 = load i8, i8* %33
%35 = getelementptr inbounds i8, i8* %0, i64 %32
%36 = load i8, i8* %35
%37 = xor i8 %36, %34
%38 = zext i8 %37 to i64
%39 = add nuw nsw i64 %26, 2
%40 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %38
%41 = load i8, i8* %40
%42 = getelementptr inbounds i8, i8* %0, i64 %39
%43 = load i8, i8* %42
%44 = xor i8 %43, %41
%45 = zext i8 %44 to i64
%46 = add nuw i64 %26, 3
%47 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %45
%48 = load i8, i8* %47
%49 = getelementptr inbounds i8, i8* %0, i64 %46
%50 = load i8, i8* %49
%51 = xor i8 %50, %48
%52 = zext i8 %51 to i64
%53 = add nuw i64 %26, 4
%54 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %52
%55 = load i8, i8* %54
%56 = add i64 %27, 4
%57 = icmp eq i64 %56, %18
br i1 %57, label %58, label %24
58: ; preds = %24, %12
%59 = phi i8 [ undef, %12 ], [ %55, %24 ]
%60 = phi i8 [ %11, %12 ], [ %55, %24 ]
%61 = phi i64 [ 1, %12 ], [ %53, %24 ]
%62 = icmp eq i64 %15, 0
br i1 %62, label %76, label %63
63: ; preds = %58, %63
%64 = phi i8 [ %73, %63 ], [ %60, %58 ]
%65 = phi i64 [ %71, %63 ], [ %61, %58 ]
%66 = phi i64 [ %74, %63 ], [ 0, %58 ]
%67 = getelementptr inbounds i8, i8* %0, i64 %65
%68 = load i8, i8* %67
%69 = xor i8 %68, %64
%70 = zext i8 %69 to i64
%71 = add nuw i64 %65, 1
%72 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %70
%73 = load i8, i8* %72
%74 = add i64 %66, 1
%75 = icmp eq i64 %74, %15
br i1 %75, label %76, label %63
76: ; preds = %63, %58
%77 = phi i8 [ %59, %58 ], [ %73, %63 ]
%78 = add nuw nsw i64 %8, 1
%79 = and i64 %78, 255
%80 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %79
%81 = load i8, i8* %80
br i1 %9, label %82, label %121
82: ; preds = %76
%83 = and i64 %13, 3
%84 = icmp ult i64 %14, 3
br i1 %84, label %128, label %85
85: ; preds = %82
%86 = and i64 %13, -4
br label %87
87: ; preds = %87, %85
%88 = phi i8 [ %81, %85 ], [ %118, %87 ]
%89 = phi i64 [ 1, %85 ], [ %116, %87 ]
%90 = phi i64 [ 0, %85 ], [ %119, %87 ]
%91 = getelementptr inbounds i8, i8* %0, i64 %89
%92 = load i8, i8* %91
%93 = xor i8 %92, %88
%94 = zext i8 %93 to i64
%95 = add nuw nsw i64 %89, 1
%96 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %94
%97 = load i8, i8* %96
%98 = getelementptr inbounds i8, i8* %0, i64 %95
%99 = load i8, i8* %98
%100 = xor i8 %99, %97
%101 = zext i8 %100 to i64
%102 = add nuw nsw i64 %89, 2
%103 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %101
%104 = load i8, i8* %103
%105 = getelementptr inbounds i8, i8* %0, i64 %102
%106 = load i8, i8* %105
%107 = xor i8 %106, %104
%108 = zext i8 %107 to i64
%109 = add nuw i64 %89, 3
%110 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %108
%111 = load i8, i8* %110
%112 = getelementptr inbounds i8, i8* %0, i64 %109
%113 = load i8, i8* %112
%114 = xor i8 %113, %111
%115 = zext i8 %114 to i64
%116 = add nuw i64 %89, 4
%117 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %115
%118 = load i8, i8* %117
%119 = add i64 %90, 4
%120 = icmp eq i64 %119, %86
br i1 %120, label %128, label %87
121: ; preds = %19, %76
%122 = phi i8 [ %11, %19 ], [ %77, %76 ]
%123 = phi i8 [ %23, %19 ], [ %81, %76 ]
%124 = add nuw nsw i64 %8, 2
%125 = and i64 %124, 255
%126 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %125
%127 = load i8, i8* %126
br label %191
128: ; preds = %87, %82
%129 = phi i8 [ undef, %82 ], [ %118, %87 ]
%130 = phi i8 [ %81, %82 ], [ %118, %87 ]
%131 = phi i64 [ 1, %82 ], [ %116, %87 ]
%132 = icmp eq i64 %83, 0
br i1 %132, label %146, label %133
133: ; preds = %128, %133
%134 = phi i8 [ %143, %133 ], [ %130, %128 ]
%135 = phi i64 [ %141, %133 ], [ %131, %128 ]
%136 = phi i64 [ %144, %133 ], [ 0, %128 ]
%137 = getelementptr inbounds i8, i8* %0, i64 %135
%138 = load i8, i8* %137
%139 = xor i8 %138, %134
%140 = zext i8 %139 to i64
%141 = add nuw i64 %135, 1
%142 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %140
%143 = load i8, i8* %142
%144 = add i64 %136, 1
%145 = icmp eq i64 %144, %83
br i1 %145, label %146, label %133
146: ; preds = %133, %128
%147 = phi i8 [ %129, %128 ], [ %143, %133 ]
%148 = add nuw nsw i64 %8, 2
%149 = and i64 %148, 255
%150 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %149
%151 = load i8, i8* %150
br i1 %9, label %152, label %191
152: ; preds = %146
%153 = and i64 %13, 3
%154 = icmp ult i64 %14, 3
br i1 %154, label %199, label %155
155: ; preds = %152
%156 = and i64 %13, -4
br label %157
157: ; preds = %157, %155
%158 = phi i8 [ %151, %155 ], [ %188, %157 ]
%159 = phi i64 [ 1, %155 ], [ %186, %157 ]
%160 = phi i64 [ 0, %155 ], [ %189, %157 ]
%161 = getelementptr inbounds i8, i8* %0, i64 %159
%162 = load i8, i8* %161
%163 = xor i8 %162, %158
%164 = zext i8 %163 to i64
%165 = add nuw nsw i64 %159, 1
%166 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %164
%167 = load i8, i8* %166
%168 = getelementptr inbounds i8, i8* %0, i64 %165
%169 = load i8, i8* %168
%170 = xor i8 %169, %167
%171 = zext i8 %170 to i64
%172 = add nuw nsw i64 %159, 2
%173 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %171
%174 = load i8, i8* %173
%175 = getelementptr inbounds i8, i8* %0, i64 %172
%176 = load i8, i8* %175
%177 = xor i8 %176, %174
%178 = zext i8 %177 to i64
%179 = add nuw i64 %159, 3
%180 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %178
%181 = load i8, i8* %180
%182 = getelementptr inbounds i8, i8* %0, i64 %179
%183 = load i8, i8* %182
%184 = xor i8 %183, %181
%185 = zext i8 %184 to i64
%186 = add nuw i64 %159, 4
%187 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %185
%188 = load i8, i8* %187
%189 = add i64 %160, 4
%190 = icmp eq i64 %189, %156
br i1 %190, label %199, label %157
191: ; preds = %121, %146
%192 = phi i8 [ %123, %121 ], [ %147, %146 ]
%193 = phi i8 [ %122, %121 ], [ %77, %146 ]
%194 = phi i8 [ %127, %121 ], [ %151, %146 ]
%195 = add nuw nsw i64 %8, 3
%196 = and i64 %195, 255
%197 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %196
%198 = load i8, i8* %197
br label %262
199: ; preds = %157, %152
%200 = phi i8 [ undef, %152 ], [ %188, %157 ]
%201 = phi i8 [ %151, %152 ], [ %188, %157 ]
%202 = phi i64 [ 1, %152 ], [ %186, %157 ]
%203 = icmp eq i64 %153, 0
br i1 %203, label %217, label %204
204: ; preds = %199, %204
%205 = phi i8 [ %214, %204 ], [ %201, %199 ]
%206 = phi i64 [ %212, %204 ], [ %202, %199 ]
%207 = phi i64 [ %215, %204 ], [ 0, %199 ]
%208 = getelementptr inbounds i8, i8* %0, i64 %206
%209 = load i8, i8* %208
%210 = xor i8 %209, %205
%211 = zext i8 %210 to i64
%212 = add nuw i64 %206, 1
%213 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %211
%214 = load i8, i8* %213
%215 = add i64 %207, 1
%216 = icmp eq i64 %215, %153
br i1 %216, label %217, label %204
217: ; preds = %204, %199
%218 = phi i8 [ %200, %199 ], [ %214, %204 ]
%219 = add nuw nsw i64 %8, 3
%220 = and i64 %219, 255
%221 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %220
%222 = load i8, i8* %221
br i1 %9, label %223, label %262
223: ; preds = %217
%224 = and i64 %13, 3
%225 = icmp ult i64 %14, 3
br i1 %225, label %271, label %226
226: ; preds = %223
%227 = and i64 %13, -4
br label %228
228: ; preds = %228, %226
%229 = phi i8 [ %222, %226 ], [ %259, %228 ]
%230 = phi i64 [ 1, %226 ], [ %257, %228 ]
%231 = phi i64 [ 0, %226 ], [ %260, %228 ]
%232 = getelementptr inbounds i8, i8* %0, i64 %230
%233 = load i8, i8* %232
%234 = xor i8 %233, %229
%235 = zext i8 %234 to i64
%236 = add nuw nsw i64 %230, 1
%237 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %235
%238 = load i8, i8* %237
%239 = getelementptr inbounds i8, i8* %0, i64 %236
%240 = load i8, i8* %239
%241 = xor i8 %240, %238
%242 = zext i8 %241 to i64
%243 = add nuw nsw i64 %230, 2
%244 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %242
%245 = load i8, i8* %244
%246 = getelementptr inbounds i8, i8* %0, i64 %243
%247 = load i8, i8* %246
%248 = xor i8 %247, %245
%249 = zext i8 %248 to i64
%250 = add nuw i64 %230, 3
%251 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %249
%252 = load i8, i8* %251
%253 = getelementptr inbounds i8, i8* %0, i64 %250
%254 = load i8, i8* %253
%255 = xor i8 %254, %252
%256 = zext i8 %255 to i64
%257 = add nuw i64 %230, 4
%258 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %256
%259 = load i8, i8* %258
%260 = add i64 %231, 4
%261 = icmp eq i64 %260, %227
br i1 %261, label %271, label %228
262: ; preds = %191, %217
%263 = phi i8 [ %194, %191 ], [ %218, %217 ]
%264 = phi i8 [ %193, %191 ], [ %77, %217 ]
%265 = phi i8 [ %192, %191 ], [ %147, %217 ]
%266 = phi i8 [ %198, %191 ], [ %222, %217 ]
%267 = add nuw nsw i64 %8, 4
%268 = and i64 %267, 255
%269 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %268
%270 = load i8, i8* %269
br label %334
271: ; preds = %228, %223
%272 = phi i8 [ undef, %223 ], [ %259, %228 ]
%273 = phi i8 [ %222, %223 ], [ %259, %228 ]
%274 = phi i64 [ 1, %223 ], [ %257, %228 ]
%275 = icmp eq i64 %224, 0
br i1 %275, label %289, label %276
276: ; preds = %271, %276
%277 = phi i8 [ %286, %276 ], [ %273, %271 ]
%278 = phi i64 [ %284, %276 ], [ %274, %271 ]
%279 = phi i64 [ %287, %276 ], [ 0, %271 ]
%280 = getelementptr inbounds i8, i8* %0, i64 %278
%281 = load i8, i8* %280
%282 = xor i8 %281, %277
%283 = zext i8 %282 to i64
%284 = add nuw i64 %278, 1
%285 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %283
%286 = load i8, i8* %285
%287 = add i64 %279, 1
%288 = icmp eq i64 %287, %224
br i1 %288, label %289, label %276
289: ; preds = %276, %271
%290 = phi i8 [ %272, %271 ], [ %286, %276 ]
%291 = add nuw nsw i64 %8, 4
%292 = and i64 %291, 255
%293 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %292
%294 = load i8, i8* %293
br i1 %9, label %295, label %334
295: ; preds = %289
%296 = and i64 %13, 3
%297 = icmp ult i64 %14, 3
br i1 %297, label %344, label %298
298: ; preds = %295
%299 = and i64 %13, -4
br label %300
300: ; preds = %300, %298
%301 = phi i8 [ %294, %298 ], [ %331, %300 ]
%302 = phi i64 [ 1, %298 ], [ %329, %300 ]
%303 = phi i64 [ 0, %298 ], [ %332, %300 ]
%304 = getelementptr inbounds i8, i8* %0, i64 %302
%305 = load i8, i8* %304
%306 = xor i8 %305, %301
%307 = zext i8 %306 to i64
%308 = add nuw nsw i64 %302, 1
%309 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %307
%310 = load i8, i8* %309
%311 = getelementptr inbounds i8, i8* %0, i64 %308
%312 = load i8, i8* %311
%313 = xor i8 %312, %310
%314 = zext i8 %313 to i64
%315 = add nuw nsw i64 %302, 2
%316 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %314
%317 = load i8, i8* %316
%318 = getelementptr inbounds i8, i8* %0, i64 %315
%319 = load i8, i8* %318
%320 = xor i8 %319, %317
%321 = zext i8 %320 to i64
%322 = add nuw i64 %302, 3
%323 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %321
%324 = load i8, i8* %323
%325 = getelementptr inbounds i8, i8* %0, i64 %322
%326 = load i8, i8* %325
%327 = xor i8 %326, %324
%328 = zext i8 %327 to i64
%329 = add nuw i64 %302, 4
%330 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %328
%331 = load i8, i8* %330
%332 = add i64 %303, 4
%333 = icmp eq i64 %332, %299
br i1 %333, label %344, label %300
334: ; preds = %262, %289
%335 = phi i8 [ %266, %262 ], [ %290, %289 ]
%336 = phi i8 [ %265, %262 ], [ %147, %289 ]
%337 = phi i8 [ %264, %262 ], [ %77, %289 ]
%338 = phi i8 [ %263, %262 ], [ %218, %289 ]
%339 = phi i8 [ %270, %262 ], [ %294, %289 ]
%340 = add nuw nsw i64 %8, 5
%341 = and i64 %340, 255
%342 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %341
%343 = load i8, i8* %342
br label %407
344: ; preds = %300, %295
%345 = phi i8 [ undef, %295 ], [ %331, %300 ]
%346 = phi i8 [ %294, %295 ], [ %331, %300 ]
%347 = phi i64 [ 1, %295 ], [ %329, %300 ]
%348 = icmp eq i64 %296, 0
br i1 %348, label %362, label %349
349: ; preds = %344, %349
%350 = phi i8 [ %359, %349 ], [ %346, %344 ]
%351 = phi i64 [ %357, %349 ], [ %347, %344 ]
%352 = phi i64 [ %360, %349 ], [ 0, %344 ]
%353 = getelementptr inbounds i8, i8* %0, i64 %351
%354 = load i8, i8* %353
%355 = xor i8 %354, %350
%356 = zext i8 %355 to i64
%357 = add nuw i64 %351, 1
%358 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %356
%359 = load i8, i8* %358
%360 = add i64 %352, 1
%361 = icmp eq i64 %360, %296
br i1 %361, label %362, label %349
362: ; preds = %349, %344
%363 = phi i8 [ %345, %344 ], [ %359, %349 ]
%364 = add nuw nsw i64 %8, 5
%365 = and i64 %364, 255
%366 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %365
%367 = load i8, i8* %366
br i1 %9, label %368, label %407
368: ; preds = %362
%369 = and i64 %13, 3
%370 = icmp ult i64 %14, 3
br i1 %370, label %418, label %371
371: ; preds = %368
%372 = and i64 %13, -4
br label %373
373: ; preds = %373, %371
%374 = phi i8 [ %367, %371 ], [ %404, %373 ]
%375 = phi i64 [ 1, %371 ], [ %402, %373 ]
%376 = phi i64 [ 0, %371 ], [ %405, %373 ]
%377 = getelementptr inbounds i8, i8* %0, i64 %375
%378 = load i8, i8* %377
%379 = xor i8 %378, %374
%380 = zext i8 %379 to i64
%381 = add nuw nsw i64 %375, 1
%382 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %380
%383 = load i8, i8* %382
%384 = getelementptr inbounds i8, i8* %0, i64 %381
%385 = load i8, i8* %384
%386 = xor i8 %385, %383
%387 = zext i8 %386 to i64
%388 = add nuw nsw i64 %375, 2
%389 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %387
%390 = load i8, i8* %389
%391 = getelementptr inbounds i8, i8* %0, i64 %388
%392 = load i8, i8* %391
%393 = xor i8 %392, %390
%394 = zext i8 %393 to i64
%395 = add nuw i64 %375, 3
%396 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %394
%397 = load i8, i8* %396
%398 = getelementptr inbounds i8, i8* %0, i64 %395
%399 = load i8, i8* %398
%400 = xor i8 %399, %397
%401 = zext i8 %400 to i64
%402 = add nuw i64 %375, 4
%403 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %401
%404 = load i8, i8* %403
%405 = add i64 %376, 4
%406 = icmp eq i64 %405, %372
br i1 %406, label %418, label %373
407: ; preds = %334, %362
%408 = phi i8 [ %339, %334 ], [ %363, %362 ]
%409 = phi i8 [ %338, %334 ], [ %218, %362 ]
%410 = phi i8 [ %337, %334 ], [ %77, %362 ]
%411 = phi i8 [ %336, %334 ], [ %147, %362 ]
%412 = phi i8 [ %335, %334 ], [ %290, %362 ]
%413 = phi i8 [ %343, %334 ], [ %367, %362 ]
%414 = add nuw nsw i64 %8, 6
%415 = and i64 %414, 255
%416 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %415
%417 = load i8, i8* %416
br label %481
418: ; preds = %373, %368
%419 = phi i8 [ undef, %368 ], [ %404, %373 ]
%420 = phi i8 [ %367, %368 ], [ %404, %373 ]
%421 = phi i64 [ 1, %368 ], [ %402, %373 ]
%422 = icmp eq i64 %369, 0
br i1 %422, label %436, label %423
423: ; preds = %418, %423
%424 = phi i8 [ %433, %423 ], [ %420, %418 ]
%425 = phi i64 [ %431, %423 ], [ %421, %418 ]
%426 = phi i64 [ %434, %423 ], [ 0, %418 ]
%427 = getelementptr inbounds i8, i8* %0, i64 %425
%428 = load i8, i8* %427
%429 = xor i8 %428, %424
%430 = zext i8 %429 to i64
%431 = add nuw i64 %425, 1
%432 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %430
%433 = load i8, i8* %432
%434 = add i64 %426, 1
%435 = icmp eq i64 %434, %369
br i1 %435, label %436, label %423
436: ; preds = %423, %418
%437 = phi i8 [ %419, %418 ], [ %433, %423 ]
%438 = add nuw nsw i64 %8, 6
%439 = and i64 %438, 255
%440 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %439
%441 = load i8, i8* %440
br i1 %9, label %442, label %481
442: ; preds = %436
%443 = and i64 %13, 3
%444 = icmp ult i64 %14, 3
br i1 %444, label %493, label %445
445: ; preds = %442
%446 = and i64 %13, -4
br label %447
447: ; preds = %447, %445
%448 = phi i8 [ %441, %445 ], [ %478, %447 ]
%449 = phi i64 [ 1, %445 ], [ %476, %447 ]
%450 = phi i64 [ 0, %445 ], [ %479, %447 ]
%451 = getelementptr inbounds i8, i8* %0, i64 %449
%452 = load i8, i8* %451
%453 = xor i8 %452, %448
%454 = zext i8 %453 to i64
%455 = add nuw nsw i64 %449, 1
%456 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %454
%457 = load i8, i8* %456
%458 = getelementptr inbounds i8, i8* %0, i64 %455
%459 = load i8, i8* %458
%460 = xor i8 %459, %457
%461 = zext i8 %460 to i64
%462 = add nuw nsw i64 %449, 2
%463 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %461
%464 = load i8, i8* %463
%465 = getelementptr inbounds i8, i8* %0, i64 %462
%466 = load i8, i8* %465
%467 = xor i8 %466, %464
%468 = zext i8 %467 to i64
%469 = add nuw i64 %449, 3
%470 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %468
%471 = load i8, i8* %470
%472 = getelementptr inbounds i8, i8* %0, i64 %469
%473 = load i8, i8* %472
%474 = xor i8 %473, %471
%475 = zext i8 %474 to i64
%476 = add nuw i64 %449, 4
%477 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %475
%478 = load i8, i8* %477
%479 = add i64 %450, 4
%480 = icmp eq i64 %479, %446
br i1 %480, label %493, label %447
481: ; preds = %407, %436
%482 = phi i8 [ %413, %407 ], [ %437, %436 ]
%483 = phi i8 [ %412, %407 ], [ %290, %436 ]
%484 = phi i8 [ %411, %407 ], [ %147, %436 ]
%485 = phi i8 [ %410, %407 ], [ %77, %436 ]
%486 = phi i8 [ %409, %407 ], [ %218, %436 ]
%487 = phi i8 [ %408, %407 ], [ %363, %436 ]
%488 = phi i8 [ %417, %407 ], [ %441, %436 ]
%489 = add nuw nsw i64 %8, 7
%490 = and i64 %489, 255
%491 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %490
%492 = load i8, i8* %491
br label %574
493: ; preds = %447, %442
%494 = phi i8 [ undef, %442 ], [ %478, %447 ]
%495 = phi i8 [ %441, %442 ], [ %478, %447 ]
%496 = phi i64 [ 1, %442 ], [ %476, %447 ]
%497 = icmp eq i64 %443, 0
br i1 %497, label %511, label %498
498: ; preds = %493, %498
%499 = phi i8 [ %508, %498 ], [ %495, %493 ]
%500 = phi i64 [ %506, %498 ], [ %496, %493 ]
%501 = phi i64 [ %509, %498 ], [ 0, %493 ]
%502 = getelementptr inbounds i8, i8* %0, i64 %500
%503 = load i8, i8* %502
%504 = xor i8 %503, %499
%505 = zext i8 %504 to i64
%506 = add nuw i64 %500, 1
%507 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %505
%508 = load i8, i8* %507
%509 = add i64 %501, 1
%510 = icmp eq i64 %509, %443
br i1 %510, label %511, label %498
511: ; preds = %498, %493
%512 = phi i8 [ %494, %493 ], [ %508, %498 ]
%513 = add nuw nsw i64 %8, 7
%514 = and i64 %513, 255
%515 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %514
%516 = load i8, i8* %515
br i1 %9, label %517, label %574
517: ; preds = %511
%518 = and i64 %13, 3
%519 = icmp ult i64 %14, 3
br i1 %519, label %556, label %520
520: ; preds = %517
%521 = and i64 %13, -4
br label %522
522: ; preds = %522, %520
%523 = phi i8 [ %516, %520 ], [ %553, %522 ]
%524 = phi i64 [ 1, %520 ], [ %551, %522 ]
%525 = phi i64 [ 0, %520 ], [ %554, %522 ]
%526 = getelementptr inbounds i8, i8* %0, i64 %524
%527 = load i8, i8* %526
%528 = xor i8 %527, %523
%529 = zext i8 %528 to i64
%530 = add nuw nsw i64 %524, 1
%531 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %529
%532 = load i8, i8* %531
%533 = getelementptr inbounds i8, i8* %0, i64 %530
%534 = load i8, i8* %533
%535 = xor i8 %534, %532
%536 = zext i8 %535 to i64
%537 = add nuw nsw i64 %524, 2
%538 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %536
%539 = load i8, i8* %538
%540 = getelementptr inbounds i8, i8* %0, i64 %537
%541 = load i8, i8* %540
%542 = xor i8 %541, %539
%543 = zext i8 %542 to i64
%544 = add nuw i64 %524, 3
%545 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %543
%546 = load i8, i8* %545
%547 = getelementptr inbounds i8, i8* %0, i64 %544
%548 = load i8, i8* %547
%549 = xor i8 %548, %546
%550 = zext i8 %549 to i64
%551 = add nuw i64 %524, 4
%552 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %550
%553 = load i8, i8* %552
%554 = add i64 %525, 4
%555 = icmp eq i64 %554, %521
br i1 %555, label %556, label %522
556: ; preds = %522, %517
%557 = phi i8 [ undef, %517 ], [ %553, %522 ]
%558 = phi i8 [ %516, %517 ], [ %553, %522 ]
%559 = phi i64 [ 1, %517 ], [ %551, %522 ]
%560 = icmp eq i64 %518, 0
br i1 %560, label %574, label %561
561: ; preds = %556, %561
%562 = phi i8 [ %571, %561 ], [ %558, %556 ]
%563 = phi i64 [ %569, %561 ], [ %559, %556 ]
%564 = phi i64 [ %572, %561 ], [ 0, %556 ]
%565 = getelementptr inbounds i8, i8* %0, i64 %563
%566 = load i8, i8* %565
%567 = xor i8 %566, %562
%568 = zext i8 %567 to i64
%569 = add nuw i64 %563, 1
%570 = getelementptr inbounds [256 x i8], [256 x i8]* @pearson64.tab, i64 0, i64 %568
%571 = load i8, i8* %570
%572 = add i64 %564, 1
%573 = icmp eq i64 %572, %518
br i1 %573, label %574, label %561
574: ; preds = %556, %561, %481, %511
%575 = phi i8 [ %512, %511 ], [ %488, %481 ], [ %512, %561 ], [ %512, %556 ]
%576 = phi i8 [ %363, %511 ], [ %487, %481 ], [ %363, %561 ], [ %363, %556 ]
%577 = phi i8 [ %218, %511 ], [ %486, %481 ], [ %218, %561 ], [ %218, %556 ]
%578 = phi i8 [ %77, %511 ], [ %485, %481 ], [ %77, %561 ], [ %77, %556 ]
%579 = phi i8 [ %147, %511 ], [ %484, %481 ], [ %147, %561 ], [ %147, %556 ]
%580 = phi i8 [ %290, %511 ], [ %483, %481 ], [ %290, %561 ], [ %290, %556 ]
%581 = phi i8 [ %437, %511 ], [ %482, %481 ], [ %437, %561 ], [ %437, %556 ]
%582 = phi i8 [ %516, %511 ], [ %492, %481 ], [ %557, %556 ], [ %571, %561 ]
%583 = zext i8 %578 to i64
%584 = zext i8 %579 to i64
%585 = shl nuw nsw i64 %584, 8
%586 = or i64 %585, %583
%587 = zext i8 %577 to i64
%588 = shl nuw nsw i64 %587, 16
%589 = or i64 %588, %586
%590 = zext i8 %580 to i64
%591 = shl nuw nsw i64 %590, 24
%592 = or i64 %591, %589
%593 = zext i8 %576 to i64
%594 = shl nuw nsw i64 %593, 32
%595 = or i64 %594, %592
%596 = zext i8 %581 to i64
%597 = shl nuw nsw i64 %596, 40
%598 = or i64 %597, %595
%599 = zext i8 %575 to i64
%600 = shl nuw nsw i64 %599, 48
%601 = or i64 %600, %598
%602 = zext i8 %582 to i64
%603 = shl nuw i64 %602, 56
%604 = or i64 %603, %601
ret i64 %604
}