#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 */
scalar_t__ myMalloc(int);
int parseAllPostingList(unsigned int *nlists, unsigned int **lenList,
                        unsigned int ***occList, unsigned int *maxPostValue,
                        unsigned int *source, unsigned int length) {
  unsigned int **occs;
  unsigned int *lens;
  unsigned int n;
  register unsigned int i, j, sourcepos, len;
  if (length < 2)
    return 1;
  n = source[0];
  *maxPostValue = source[1];
  lens = (unsigned int *)myMalloc(sizeof(unsigned int) * n);
  occs = (unsigned int **)myMalloc(sizeof(unsigned int *) * n);
  sourcepos = 2;
  for (i = 0; i < n; i++) {
    lens[i] = len = source[sourcepos++];
    occs[i] = (unsigned int *)myMalloc(sizeof(unsigned int) * len);
    for (j = 0; j < len; j++)
      occs[i][j] = source[sourcepos++];
  }
  if (length != sourcepos)
    return 31;
  *nlists = n;
  *lenList = lens;
  *occList = occs;
  return 0;
}


x86 assembly (clang, -O0):
<parseAllPostingList>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9d,-0x34(%rbp)
cmpl   $0x2,-0x34(%rbp)
jae    1146 <parseAllPostingList+0x36>
movl   $0x1,-0x4(%rbp)
jmp    126e <parseAllPostingList+0x15e>
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%rax
mov    0x4(%rax),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x4c(%rbp),%eax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <myMalloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x4c(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1030 <myMalloc@plt>
mov    %rax,-0x40(%rbp)
movl   $0x2,-0x58(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jae    1230 <parseAllPostingList+0x120>
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x58(%rbp)
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%edx
mov    %edx,-0x5c(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x5c(%rbp),%eax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <myMalloc@plt>
mov    %rax,%rdx
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    %rdx,(%rax,%rcx,8)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x5c(%rbp),%eax
jae    121d <parseAllPostingList+0x10d>
mov    -0x30(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x58(%rbp)
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%edx
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x54(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    11de <parseAllPostingList+0xce>
jmp    1222 <parseAllPostingList+0x112>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    118e <parseAllPostingList+0x7e>
mov    -0x34(%rbp),%eax
cmp    -0x58(%rbp),%eax
je     1248 <parseAllPostingList+0x138>
movl   $0x1f,-0x4(%rbp)
jmp    126e <parseAllPostingList+0x15e>
mov    -0x4c(%rbp),%ecx
mov    -0x10(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x48(%rbp),%rcx
mov    -0x18(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x40(%rbp),%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parseAllPostingList>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    $0x1,%eax
cmp    $0x2,%r9d
jb     13bb <parseAllPostingList+0x2ab>
mov    %r8,%rbx
mov    %r9d,0x4(%rsp)
mov    %rdi,0x10(%rsp)
mov    %rsi,0x18(%rsp)
mov    %rdx,0x20(%rsp)
mov    (%r8),%r15d
mov    0x4(%r8),%eax
mov    %eax,(%rcx)
lea    0x0(,%r15,4),%edi
call   1030 <myMalloc@plt>
mov    %rax,0x8(%rsp)
lea    0x0(,%r15,8),%edi
call   1030 <myMalloc@plt>
mov    %rax,%r14
mov    $0x2,%ebp
test   %r15,%r15
je     1391 <parseAllPostingList+0x281>
xor    %r12d,%r12d
jmp    119f <parseAllPostingList+0x8f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ecx,%ebp
add    $0x1,%r12
cmp    %r15,%r12
je     1391 <parseAllPostingList+0x281>
mov    %ebp,%eax
mov    (%rbx,%rax,4),%r13d
mov    0x8(%rsp),%rax
mov    %r13d,(%rax,%r12,4)
lea    0x0(,%r13,4),%edi
call   1030 <myMalloc@plt>
lea    0x1(%rbp),%ecx
mov    %rax,(%r14,%r12,8)
test   %r13,%r13
je     1190 <parseAllPostingList+0x80>
cmp    $0x8,%r13d
jb     1210 <parseAllPostingList+0x100>
lea    -0x1(%r13),%rdx
mov    $0xfffffffe,%esi
sub    %ebp,%esi
cmp    %edx,%esi
jb     1210 <parseAllPostingList+0x100>
shr    $0x20,%rdx
jne    1210 <parseAllPostingList+0x100>
mov    %ecx,%edx
lea    (%rdx,%r13,1),%rsi
lea    (%rbx,%rsi,4),%rsi
cmp    %rsi,%rax
jae    1297 <parseAllPostingList+0x187>
lea    (%rax,%r13,4),%rsi
lea    (%rbx,%rdx,4),%rdx
cmp    %rsi,%rdx
jae    1297 <parseAllPostingList+0x187>
cs nopw 0x0(%rax,%rax,1)
xor    %edx,%edx
mov    %rdx,%rsi
not    %rsi
add    %r13,%rsi
mov    %r13,%rdi
and    $0x3,%rdi
je     1245 <parseAllPostingList+0x135>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %ecx,%ebp
mov    (%rbx,%rbp,4),%ebp
mov    %ebp,(%rax,%rdx,4)
add    $0x1,%rdx
add    $0x1,%ecx
add    $0xffffffffffffffff,%rdi
jne    1230 <parseAllPostingList+0x120>
mov    %ecx,%ebp
cmp    $0x3,%rsi
jb     1192 <parseAllPostingList+0x82>
mov    %ecx,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %ebp,%ecx
mov    (%rbx,%rcx,4),%ecx
mov    %ecx,(%rax,%rdx,4)
lea    0x1(%rbp),%ecx
mov    (%rbx,%rcx,4),%ecx
mov    %ecx,0x4(%rax,%rdx,4)
lea    0x2(%rbp),%ecx
mov    (%rbx,%rcx,4),%ecx
mov    %ecx,0x8(%rax,%rdx,4)
lea    0x3(%rbp),%ecx
mov    (%rbx,%rcx,4),%ecx
mov    %ecx,0xc(%rax,%rdx,4)
add    $0x4,%rdx
add    $0x4,%ebp
cmp    %rdx,%r13
jne    1260 <parseAllPostingList+0x150>
jmp    1192 <parseAllPostingList+0x82>
mov    %r13d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rsi
mov    %rsi,%r9
shr    $0x3,%r9
add    $0x1,%r9
mov    %r9d,%r8d
and    $0x3,%r8d
cmp    $0x18,%rsi
jae    12c0 <parseAllPostingList+0x1b0>
xor    %esi,%esi
jmp    133f <parseAllPostingList+0x22f>
and    $0xfffffffffffffffc,%r9
lea    0x11(%rbp),%edi
xor    %esi,%esi
nopl   0x0(%rax)
lea    -0x10(%rdi),%r10d
movups (%rbx,%r10,4),%xmm0
movups 0x10(%rbx,%r10,4),%xmm1
movups %xmm0,(%rax,%rsi,4)
movups %xmm1,0x10(%rax,%rsi,4)
lea    -0x8(%rdi),%r10d
movups (%rbx,%r10,4),%xmm0
movups 0x10(%rbx,%r10,4),%xmm1
movups %xmm0,0x20(%rax,%rsi,4)
movups %xmm1,0x30(%rax,%rsi,4)
mov    %edi,%r10d
movups (%rbx,%r10,4),%xmm0
movups 0x10(%rbx,%r10,4),%xmm1
movups %xmm0,0x40(%rax,%rsi,4)
movups %xmm1,0x50(%rax,%rsi,4)
lea    0x8(%rdi),%r10d
movups (%rbx,%r10,4),%xmm0
movups 0x10(%rbx,%r10,4),%xmm1
movups %xmm0,0x60(%rax,%rsi,4)
movups %xmm1,0x70(%rax,%rsi,4)
add    $0x20,%rsi
add    $0x20,%edi
add    $0xfffffffffffffffc,%r9
jne    12d0 <parseAllPostingList+0x1c0>
test   %r8,%r8
je     137f <parseAllPostingList+0x26f>
lea    (%rax,%rsi,4),%rdi
add    $0x10,%rdi
lea    (%rsi,%rbp,1),%r9d
add    $0x1,%r9d
shl    $0x3,%r8
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
lea    (%r9,%rbp,1),%esi
movups (%rbx,%rsi,4),%xmm0
movups 0x10(%rbx,%rsi,4),%xmm1
movups %xmm0,-0x10(%rdi,%rbp,4)
movups %xmm1,(%rdi,%rbp,4)
add    $0x8,%rbp
cmp    %rbp,%r8
jne    1360 <parseAllPostingList+0x250>
add    %edx,%ecx
mov    %ecx,%ebp
cmp    %r13,%rdx
je     1192 <parseAllPostingList+0x82>
jmp    1212 <parseAllPostingList+0x102>
mov    $0x1f,%eax
cmp    0x4(%rsp),%ebp
mov    0x20(%rsp),%rcx
mov    0x18(%rsp),%rdx
mov    0x10(%rsp),%rsi
jne    13bb <parseAllPostingList+0x2ab>
mov    %r15d,(%rsi)
mov    0x8(%rsp),%rax
mov    %rax,(%rdx)
mov    %r14,(%rcx)
xor    %eax,%eax
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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