#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*/ applyArr(int **, int);
int /*<<< orphan*/ freeArr(int **);
int *upfrontGoodSuffix(char *, int);
int *goodSuffix(char *pattern, int len) {
  if (!pattern || 0 >= len) {
    return NULL;
  }
  int *arr, *suffixArr;
  applyArr(&arr, len);
  if (!arr) {
    return NULL;
  }
  suffixArr = upfrontGoodSuffix(pattern, len);
  if (!suffixArr) {
    freeArr(&arr);
    return NULL;
  }
  int i = 0;
  while (i < len) {
    arr[i++] = len;
  }
  int j = 0;
  for (i = len - 1; i >= 0; i--) {
    if (i + 1 == suffixArr[i]) {
      while (j < len - 1 - i) {
        if (len == arr[j]) {
          arr[j] = len - 1 - i;
        }
        j++;
      }
    }
  }
  for (i = 0; i < len - 1; i++) {
    arr[len - 1 - suffixArr[i]] = len - 1 - i;
  }
  freeArr(&suffixArr);
  return arr;
}


x86 assembly (clang, -O0):
<goodSuffix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1155 <goodSuffix+0x25>
xor    %eax,%eax
cmp    -0x14(%rbp),%eax
jl     1162 <goodSuffix+0x32>
movq   $0x0,-0x8(%rbp)
jmp    12da <goodSuffix+0x1aa>
mov    -0x14(%rbp),%esi
lea    -0x20(%rbp),%rdi
call   1050 <applyArr@plt>
cmpq   $0x0,-0x20(%rbp)
jne    1186 <goodSuffix+0x56>
movq   $0x0,-0x8(%rbp)
jmp    12da <goodSuffix+0x1aa>
mov    -0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   1030 <upfrontGoodSuffix@plt>
mov    %rax,-0x28(%rbp)
cmpq   $0x0,-0x28(%rbp)
jne    11b7 <goodSuffix+0x87>
lea    -0x20(%rbp),%rdi
call   1040 <freeArr@plt>
movq   $0x0,-0x8(%rbp)
jmp    12da <goodSuffix+0x1aa>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11e7 <goodSuffix+0xb7>
mov    -0x14(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x2c(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    11be <goodSuffix+0x8e>
movl   $0x0,-0x30(%rbp)
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x0,-0x2c(%rbp)
jl     127f <goodSuffix+0x14f>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    -0x28(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    126c <goodSuffix+0x13c>
jmp    121d <goodSuffix+0xed>
mov    -0x30(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
sub    -0x2c(%rbp),%ecx
cmp    %ecx,%eax
jge    1267 <goodSuffix+0x137>
mov    -0x14(%rbp),%eax
mov    -0x20(%rbp),%rcx
movslq -0x30(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jne    1259 <goodSuffix+0x129>
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
sub    -0x2c(%rbp),%edx
mov    -0x20(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    121d <goodSuffix+0xed>
jmp    126c <goodSuffix+0x13c>
jmp    1271 <goodSuffix+0x141>
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    11f7 <goodSuffix+0xc7>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    12c9 <goodSuffix+0x199>
mov    -0x14(%rbp),%edx
sub    $0x1,%edx
sub    -0x2c(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
mov    -0x28(%rbp),%rsi
movslq -0x2c(%rbp),%rdi
sub    (%rsi,%rdi,4),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1286 <goodSuffix+0x156>
lea    -0x28(%rbp),%rdi
call   1040 <freeArr@plt>
mov    -0x20(%rbp),%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<goodSuffix>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
sub    $0x10,%rsp
xor    %eax,%eax
test   %rdi,%rdi
je     1472 <goodSuffix+0x342>
mov    %esi,%r15d
test   %esi,%esi
jle    1472 <goodSuffix+0x342>
mov    %rdi,%r14
mov    %rsp,%rdi
mov    %r15d,%esi
call   1050 <applyArr@plt>
cmpq   $0x0,(%rsp)
je     1195 <goodSuffix+0x65>
mov    %r14,%rdi
mov    %r15d,%esi
call   1030 <upfrontGoodSuffix@plt>
mov    %rax,0x8(%rsp)
test   %rax,%rax
je     119c <goodSuffix+0x6c>
mov    (%rsp),%rcx
mov    %r15d,%r9d
movd   %r15d,%xmm0
cmp    $0x8,%r15d
jae    11ab <goodSuffix+0x7b>
xor    %edx,%edx
jmp    12a0 <goodSuffix+0x170>
xor    %eax,%eax
jmp    1472 <goodSuffix+0x342>
mov    %rsp,%rdi
call   1040 <freeArr@plt>
xor    %eax,%eax
jmp    1472 <goodSuffix+0x342>
mov    %r9d,%edx
and    $0xfffffff8,%edx
pshufd $0x0,%xmm0,%xmm1
lea    -0x8(%rdx),%rbx
mov    %rbx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x7,%esi
cmp    $0x38,%rbx
jae    11d7 <goodSuffix+0xa7>
xor    %ebx,%ebx
jmp    1265 <goodSuffix+0x135>
and    $0xfffffffffffffff8,%rdi
xor    %ebx,%ebx
nopl   (%rax)
movdqu %xmm1,(%rcx,%rbx,4)
movdqu %xmm1,0x10(%rcx,%rbx,4)
movdqu %xmm1,0x20(%rcx,%rbx,4)
movdqu %xmm1,0x30(%rcx,%rbx,4)
movdqu %xmm1,0x40(%rcx,%rbx,4)
movdqu %xmm1,0x50(%rcx,%rbx,4)
movdqu %xmm1,0x60(%rcx,%rbx,4)
movdqu %xmm1,0x70(%rcx,%rbx,4)
movdqu %xmm1,0x80(%rcx,%rbx,4)
movdqu %xmm1,0x90(%rcx,%rbx,4)
movdqu %xmm1,0xa0(%rcx,%rbx,4)
movdqu %xmm1,0xb0(%rcx,%rbx,4)
movdqu %xmm1,0xc0(%rcx,%rbx,4)
movdqu %xmm1,0xd0(%rcx,%rbx,4)
movdqu %xmm1,0xe0(%rcx,%rbx,4)
movdqu %xmm1,0xf0(%rcx,%rbx,4)
add    $0x40,%rbx
add    $0xfffffffffffffff8,%rdi
jne    11e0 <goodSuffix+0xb0>
test   %rsi,%rsi
je     1294 <goodSuffix+0x164>
lea    (%rcx,%rbx,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rsi
xor    %ebx,%ebx
nopl   0x0(%rax,%rax,1)
movdqu %xmm1,-0x10(%rdi,%rbx,1)
movdqu %xmm1,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%rsi
jne    1280 <goodSuffix+0x150>
cmp    %r9,%rdx
je     12ad <goodSuffix+0x17d>
nopl   0x0(%rax)
mov    %r15d,(%rcx,%rdx,4)
add    $0x1,%rdx
cmp    %rdx,%r9
jne    12a0 <goodSuffix+0x170>
lea    -0x1(%r15),%r8d
mov    (%rsp),%r12
pshufd $0x0,%xmm0,%xmm0
xor    %edi,%edi
mov    %r8,%r14
xor    %edx,%edx
jmp    12e3 <goodSuffix+0x1b3>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %edi,%edx
add    $0xffffffffffffffff,%r14
add    $0x1,%rdi
cmp    %r9,%rdi
je     13f9 <goodSuffix+0x2c9>
lea    0x1(%r14),%rcx
mov    (%rax,%r14,4),%esi
cmp    %rsi,%rcx
jne    12d2 <goodSuffix+0x1a2>
mov    %r8,%rcx
sub    %r14,%rcx
movslq %edx,%rsi
cmp    %rsi,%rcx
jle    12d2 <goodSuffix+0x1a2>
mov    %rdi,%r10
sub    %rsi,%r10
cmp    $0x8,%r10
jae    1312 <goodSuffix+0x1e2>
mov    %rsi,%rbx
jmp    13ed <goodSuffix+0x2bd>
mov    %r10,%r11
and    $0xfffffffffffffff8,%r11
lea    (%r11,%rsi,1),%rbx
lea    (%r12,%rsi,4),%rdx
xor    %esi,%esi
jmp    133d <goodSuffix+0x20d>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x8,%rsi
cmp    %rsi,%r11
je     13ce <goodSuffix+0x29e>
movdqu (%rdx,%rsi,4),%xmm1
pcmpeqd %xmm0,%xmm1
movd   %xmm1,%ebp
test   $0x1,%bpl
je     1353 <goodSuffix+0x223>
mov    %ecx,(%rdx,%rsi,4)
pextrw $0x2,%xmm1,%ebp
test   $0x1,%bpl
je     1362 <goodSuffix+0x232>
mov    %ecx,0x4(%rdx,%rsi,4)
pextrw $0x4,%xmm1,%ebp
test   $0x1,%bpl
je     1371 <goodSuffix+0x241>
mov    %ecx,0x8(%rdx,%rsi,4)
pextrw $0x6,%xmm1,%ebp
test   $0x1,%bpl
je     1380 <goodSuffix+0x250>
mov    %ecx,0xc(%rdx,%rsi,4)
movdqu 0x10(%rdx,%rsi,4),%xmm1
pcmpeqd %xmm0,%xmm1
movd   %xmm1,%ebp
test   $0x1,%bpl
je     1398 <goodSuffix+0x268>
mov    %ecx,0x10(%rdx,%rsi,4)
pextrw $0x2,%xmm1,%ebp
test   $0x1,%bpl
je     13a7 <goodSuffix+0x277>
mov    %ecx,0x14(%rdx,%rsi,4)
pextrw $0x4,%xmm1,%ebp
test   $0x1,%bpl
je     13b6 <goodSuffix+0x286>
mov    %ecx,0x18(%rdx,%rsi,4)
pextrw $0x6,%xmm1,%ebp
test   $0x1,%bpl
je     1330 <goodSuffix+0x200>
mov    %ecx,0x1c(%rdx,%rsi,4)
jmp    1330 <goodSuffix+0x200>
cmp    %r11,%r10
jne    13ed <goodSuffix+0x2bd>
jmp    12d0 <goodSuffix+0x1a0>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rbx
cmp    %rbx,%rdi
je     12d0 <goodSuffix+0x1a0>
cmp    %r15d,(%r12,%rbx,4)
jne    13e0 <goodSuffix+0x2b0>
mov    %ecx,(%r12,%rbx,4)
jmp    13e0 <goodSuffix+0x2b0>
cmp    $0x2,%r15d
jl     1464 <goodSuffix+0x334>
mov    (%rsp),%rcx
cmp    $0x1,%r8d
jne    140d <goodSuffix+0x2dd>
xor    %edx,%edx
jmp    144d <goodSuffix+0x31d>
mov    %r8d,%r9d
and    $0xfffffffe,%r9d
add    $0xfffffffe,%r15d
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
lea    0x1(%r15),%edi
movslq (%rax,%rdx,4),%rbp
movslq %r8d,%rsi
mov    %rsi,%rbx
sub    %rbp,%rbx
mov    %edi,(%rcx,%rbx,4)
movslq 0x4(%rax,%rdx,4),%rdi
sub    %rdi,%rsi
mov    %r15d,(%rcx,%rsi,4)
add    $0x2,%rdx
add    $0xfffffffe,%r15d
cmp    %rdx,%r9
jne    1420 <goodSuffix+0x2f0>
test   $0x1,%r8b
je     1464 <goodSuffix+0x334>
movslq (%rax,%rdx,4),%rax
movslq %r8d,%rsi
sub    %edx,%r8d
sub    %rax,%rsi
mov    %r8d,(%rcx,%rsi,4)
lea    0x8(%rsp),%rdi
call   1040 <freeArr@plt>
mov    (%rsp),%rax
add    $0x10,%rsp
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

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

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