#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*/ compute_prefix(char const *, size_t, int *);
void prepare_goodsuffix_heuristic(const char *normal, size_t size,
                                  int result[size + 1]) {
  char *left = (char *)normal;
  char *right = left + size;
  char reversed[size + 1];
  char *tmp = reversed + size;
  size_t i;
  *tmp = 0;
  while (left < right)
    *(--tmp) = *(left++);
  int prefix_normal[size];
  int prefix_reversed[size];
  compute_prefix(normal, size, prefix_normal);
  compute_prefix(reversed, size, prefix_reversed);
  for (i = 0; i <= size; i++) {
    result[i] = size - prefix_normal[size - 1];
  }
  for (i = 0; i < size; i++) {
    const int j = size - prefix_reversed[i];
    const int k = i - prefix_reversed[i] + 1;
    if (result[j] > k)
      result[j] = k;
  }
}


x86 assembly (clang, -O0):
<prepare_goodsuffix_heuristic>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x10(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rdx
mov    %rdx,%rcx
add    $0x1,%rcx
mov    %rsp,%rax
mov    %rax,-0x30(%rbp)
add    $0x10,%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rax
sub    %rdx,%rax
mov    %rax,-0x68(%rbp)
mov    %rax,%rsp
mov    %rcx,-0x38(%rbp)
add    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    -0x40(%rbp),%rax
movb   $0x0,(%rax)
mov    -0x20(%rbp),%rax
cmp    -0x28(%rbp),%rax
jae    11ae <prepare_goodsuffix_heuristic+0x9e>
mov    -0x20(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x20(%rbp)
mov    (%rax),%cl
mov    -0x40(%rbp),%rax
mov    %rax,%rdx
add    $0xffffffffffffffff,%rdx
mov    %rdx,-0x40(%rbp)
mov    %cl,-0x1(%rax)
jmp    1178 <prepare_goodsuffix_heuristic+0x68>
mov    -0x10(%rbp),%rax
lea    0xf(,%rax,4),%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rdx
sub    %rcx,%rdx
mov    %rdx,-0x78(%rbp)
mov    %rdx,%rsp
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
lea    0xf(,%rax,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rcx
sub    %rsi,%rcx
mov    %rcx,-0x70(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
call   1030 <compute_prefix@plt>
mov    -0x68(%rbp),%rdi
mov    -0x70(%rbp),%rdx
mov    -0x10(%rbp),%rsi
call   1030 <compute_prefix@plt>
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x10(%rbp),%rax
ja     1259 <prepare_goodsuffix_heuristic+0x149>
mov    -0x78(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    -0x10(%rbp),%rdx
sub    $0x1,%rdx
movslq (%rcx,%rdx,4),%rcx
sub    %rcx,%rax
mov    %eax,%edx
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1216 <prepare_goodsuffix_heuristic+0x106>
movq   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    12d3 <prepare_goodsuffix_heuristic+0x1c3>
mov    -0x70(%rbp),%rcx
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%rdx
movslq (%rcx,%rdx,4),%rdx
sub    %rdx,%rax
mov    %eax,-0x5c(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x48(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
sub    %rcx,%rax
add    $0x1,%rax
mov    %eax,-0x60(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x60(%rbp),%eax
jle    12bd <prepare_goodsuffix_heuristic+0x1ad>
mov    -0x60(%rbp),%edx
mov    -0x18(%rbp),%rax
movslq -0x5c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    12c2 <prepare_goodsuffix_heuristic+0x1b2>
mov    -0x48(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x48(%rbp)
jmp    1261 <prepare_goodsuffix_heuristic+0x151>
mov    -0x30(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<prepare_goodsuffix_heuristic>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %rdx,%rbx
mov    %rsi,%r14
mov    %rsp,%r15
lea    0x10(%rsi),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r15
mov    %r15,%rsp
movb   $0x0,(%rsi,%r15,1)
test   %rsi,%rsi
jle    11a2 <prepare_goodsuffix_heuristic+0x92>
lea    (%rdi,%r14,1),%r10
lea    0x1(%rdi),%r8
cmp    %r8,%r10
mov    %r8,%r9
cmova  %r10,%r9
lea    (%r15,%r14,1),%rcx
sub    %rdi,%r9
cmp    $0x4,%r9
jb     1183 <prepare_goodsuffix_heuristic+0x73>
cmp    %r8,%r10
mov    %r8,%rax
cmova  %r10,%rax
mov    %r10,%rdx
sub    %rax,%rdx
add    %r15,%rdx
cmp    %rax,%rdx
jae    12e9 <prepare_goodsuffix_heuristic+0x1d9>
cmp    %rdi,%rcx
jbe    12e9 <prepare_goodsuffix_heuristic+0x1d9>
mov    %rdi,%rdx
add    $0xffffffffffffffff,%rcx
nopw   0x0(%rax,%rax,1)
movzbl (%rdx),%eax
add    $0x1,%rdx
mov    %al,(%rcx)
add    $0xffffffffffffffff,%rcx
cmp    %r10,%rdx
jb     1190 <prepare_goodsuffix_heuristic+0x80>
mov    %rsp,%r13
lea    0xf(,%r14,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r13
mov    %r13,%rsp
mov    %rsp,%r12
sub    %rax,%r12
mov    %r12,%rsp
mov    %r14,%rsi
mov    %r13,%rdx
call   1030 <compute_prefix@plt>
mov    %r15,%rdi
mov    %r14,%rsi
mov    %r12,%rdx
call   1030 <compute_prefix@plt>
mov    %r14d,%eax
sub    -0x4(%r13,%r14,4),%eax
lea    0x1(%r14),%rcx
cmp    $0x8,%rcx
jae    11f2 <prepare_goodsuffix_heuristic+0xe2>
xor    %edx,%edx
jmp    140f <prepare_goodsuffix_heuristic+0x2ff>
mov    %rcx,%rdx
and    $0xfffffffffffffff8,%rdx
movd   %eax,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rdx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r8d
and    $0x7,%r8d
cmp    $0x38,%rsi
jae    1225 <prepare_goodsuffix_heuristic+0x115>
xor    %esi,%esi
jmp    12b5 <prepare_goodsuffix_heuristic+0x1a5>
and    $0xfffffffffffffff8,%rdi
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,(%rbx,%rsi,4)
movdqu %xmm0,0x10(%rbx,%rsi,4)
movdqu %xmm0,0x20(%rbx,%rsi,4)
movdqu %xmm0,0x30(%rbx,%rsi,4)
movdqu %xmm0,0x40(%rbx,%rsi,4)
movdqu %xmm0,0x50(%rbx,%rsi,4)
movdqu %xmm0,0x60(%rbx,%rsi,4)
movdqu %xmm0,0x70(%rbx,%rsi,4)
movdqu %xmm0,0x80(%rbx,%rsi,4)
movdqu %xmm0,0x90(%rbx,%rsi,4)
movdqu %xmm0,0xa0(%rbx,%rsi,4)
movdqu %xmm0,0xb0(%rbx,%rsi,4)
movdqu %xmm0,0xc0(%rbx,%rsi,4)
movdqu %xmm0,0xd0(%rbx,%rsi,4)
movdqu %xmm0,0xe0(%rbx,%rsi,4)
movdqu %xmm0,0xf0(%rbx,%rsi,4)
add    $0x40,%rsi
add    $0xfffffffffffffff8,%rdi
jne    1230 <prepare_goodsuffix_heuristic+0x120>
test   %r8,%r8
je     1416 <prepare_goodsuffix_heuristic+0x306>
lea    (%rbx,%rsi,4),%rsi
add    $0x10,%rsi
shl    $0x5,%r8
xor    %edi,%edi
nopl   0x0(%rax)
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm0,(%rsi,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r8
jne    12d0 <prepare_goodsuffix_heuristic+0x1c0>
jmp    1416 <prepare_goodsuffix_heuristic+0x306>
cmp    $0x20,%r9
jae    12f6 <prepare_goodsuffix_heuristic+0x1e6>
xor    %esi,%esi
jmp    139c <prepare_goodsuffix_heuristic+0x28c>
mov    %r9,%rsi
and    $0xffffffffffffffe0,%rsi
lea    (%r14,%r15,1),%rdx
add    $0xfffffffffffffff0,%rdx
xor    %eax,%eax
pxor   %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movdqu (%rdi,%rax,1),%xmm1
movdqu 0x10(%rdi,%rax,1),%xmm2
movdqa %xmm1,%xmm3
punpcklbw %xmm0,%xmm3
pshufd $0x4e,%xmm3,%xmm3
pshuflw $0x1b,%xmm3,%xmm3
pshufhw $0x1b,%xmm3,%xmm3
punpckhbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
packuswb %xmm3,%xmm1
movdqu %xmm1,(%rdx)
movdqa %xmm2,%xmm1
punpcklbw %xmm0,%xmm1
pshufd $0x4e,%xmm1,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
pshufhw $0x1b,%xmm1,%xmm1
punpckhbw %xmm0,%xmm2
pshufd $0x4e,%xmm2,%xmm2
pshuflw $0x1b,%xmm2,%xmm2
pshufhw $0x1b,%xmm2,%xmm2
packuswb %xmm1,%xmm2
movdqu %xmm2,-0x10(%rdx)
add    $0x20,%rax
add    $0xffffffffffffffe0,%rdx
cmp    %rax,%rsi
jne    1310 <prepare_goodsuffix_heuristic+0x200>
cmp    %rsi,%r9
je     11a2 <prepare_goodsuffix_heuristic+0x92>
test   $0x1c,%r9b
je     1401 <prepare_goodsuffix_heuristic+0x2f1>
cmp    %r8,%r10
cmova  %r10,%r8
sub    %rdi,%r8
mov    %r8,%r9
and    $0xfffffffffffffffc,%r9
lea    (%rdi,%r9,1),%rdx
sub    %r9,%rcx
mov    %r14,%rax
sub    %rsi,%rax
add    %r15,%rax
add    $0xfffffffffffffffc,%rax
pxor   %xmm0,%xmm0
cs nopw 0x0(%rax,%rax,1)
nop
movd   (%rdi,%rsi,1),%xmm1
punpcklbw %xmm0,%xmm1
pshuflw $0x1b,%xmm1,%xmm1
packuswb %xmm1,%xmm1
movd   %xmm1,(%rax)
add    $0x4,%rsi
add    $0xfffffffffffffffc,%rax
cmp    %rsi,%r9
jne    13d0 <prepare_goodsuffix_heuristic+0x2c0>
cmp    %r9,%r8
jne    1186 <prepare_goodsuffix_heuristic+0x76>
jmp    11a2 <prepare_goodsuffix_heuristic+0x92>
sub    %rsi,%rcx
add    %rdi,%rsi
mov    %rsi,%rdx
jmp    1186 <prepare_goodsuffix_heuristic+0x76>
mov    %eax,(%rbx,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%rcx
jne    140f <prepare_goodsuffix_heuristic+0x2ff>
test   %r14,%r14
je     1445 <prepare_goodsuffix_heuristic+0x335>
cmp    $0x1,%r14
jne    1454 <prepare_goodsuffix_heuristic+0x344>
xor    %eax,%eax
test   $0x1,%r14b
je     1445 <prepare_goodsuffix_heuristic+0x335>
mov    (%r12,%rax,4),%ecx
sub    %ecx,%r14d
sub    %ecx,%eax
add    $0x1,%eax
movslq %r14d,%rcx
cmp    %eax,(%rbx,%rcx,4)
jle    1445 <prepare_goodsuffix_heuristic+0x335>
mov    %eax,(%rbx,%rcx,4)
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r14,%rcx
and    $0xfffffffffffffffe,%rcx
xor    %eax,%eax
jmp    1469 <prepare_goodsuffix_heuristic+0x359>
nop
add    $0x2,%rax
cmp    %rax,%rcx
je     1428 <prepare_goodsuffix_heuristic+0x318>
mov    (%r12,%rax,4),%edx
mov    %r14d,%esi
sub    %edx,%esi
neg    %edx
add    %rax,%rdx
add    $0x1,%rdx
movslq %esi,%rsi
cmp    %edx,(%rbx,%rsi,4)
jle    1486 <prepare_goodsuffix_heuristic+0x376>
mov    %edx,(%rbx,%rsi,4)
mov    0x4(%r12,%rax,4),%edx
mov    %r14d,%esi
sub    %edx,%esi
neg    %edx
add    %rax,%rdx
add    $0x2,%rdx
movslq %esi,%rsi
cmp    %edx,(%rbx,%rsi,4)
jle    1460 <prepare_goodsuffix_heuristic+0x350>
mov    %edx,(%rbx,%rsi,4)
jmp    1460 <prepare_goodsuffix_heuristic+0x350>

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

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