#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*/ fprintf(int /*<<< orphan*/, char *);
scalar_t__ myMalloc(int);
int /*<<< orphan*/ printf(char *, unsigned int, unsigned int);
int /*<<< orphan*/ stderr;
int parseAllPostingList(unsigned int *nlists, unsigned int **lenList,
                        unsigned int ***occList, unsigned int *maxPostValue,
                        unsigned int *source, unsigned long length) {
  unsigned int **occs;
  unsigned int *lens;
  unsigned int n;
  register unsigned int i, j, len;
  register unsigned long sourcepos;
  if (length < 2)
    return 1;
  n = source[0];
  *maxPostValue = source[1] + 1;
  lens = (unsigned int *)myMalloc(sizeof(unsigned int) * n);
  occs = (unsigned int **)myMalloc(sizeof(unsigned int *) * n);
  sourcepos = 2;
  unsigned int maxpostL = 0;
  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] = 1 + source[sourcepos++];
      if (occs[i][j] > maxpostL)
        maxpostL = (occs[i][j]);
    }
  }
  if (maxpostL > *maxPostValue)
    *maxPostValue = maxpostL;
  printf("\n **** maxpostSource = %d, maxpostComputed = %d", *maxPostValue,
         maxpostL);
  if (length != sourcepos) {
    fprintf(stderr, "\n error in parseAllposting.lists() \n");
    return 31;
  }
  *nlists = n;
  *lenList = lens;
  *occList = occs;
  return 0;
}


x86 assembly (clang, -O0):
<parseAllPostingList>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
cmpq   $0x2,-0x38(%rbp)
jae    1167 <parseAllPostingList+0x37>
movl   $0x1,-0x4(%rbp)
jmp    1318 <parseAllPostingList+0x1e8>
mov    -0x30(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x30(%rbp),%rax
mov    0x4(%rax),%ecx
add    $0x1,%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x4c(%rbp),%eax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <myMalloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x4c(%rbp),%eax
shl    $0x3,%rax
mov    %eax,%edi
call   1040 <myMalloc@plt>
mov    %rax,-0x40(%rbp)
movq   $0x2,-0x60(%rbp)
movl   $0x0,-0x64(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jae    1296 <parseAllPostingList+0x166>
mov    -0x30(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x60(%rbp)
mov    (%rax,%rcx,4),%edx
mov    %edx,-0x58(%rbp)
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
shl    $0x2,%rax
mov    %eax,%edi
call   1040 <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    -0x58(%rbp),%eax
jae    1283 <parseAllPostingList+0x153>
mov    -0x30(%rbp),%rax
mov    -0x60(%rbp),%rcx
mov    %rcx,%rdx
add    $0x1,%rdx
mov    %rdx,-0x60(%rbp)
mov    (%rax,%rcx,4),%edx
add    $0x1,%edx
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x54(%rbp),%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x54(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
cmp    -0x64(%rbp),%eax
jbe    1270 <parseAllPostingList+0x140>
mov    -0x40(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    (%rax,%rcx,8),%rax
mov    -0x54(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x64(%rbp)
jmp    1275 <parseAllPostingList+0x145>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    120c <parseAllPostingList+0xdc>
jmp    1288 <parseAllPostingList+0x158>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    11ba <parseAllPostingList+0x8a>
mov    -0x64(%rbp),%eax
mov    -0x28(%rbp),%rcx
cmp    (%rcx),%eax
jbe    12ae <parseAllPostingList+0x17e>
mov    -0x64(%rbp),%ecx
mov    -0x28(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%rax
mov    (%rax),%esi
mov    -0x64(%rbp),%edx
lea    0xd42(%rip),%rdi
call   1030 <printf@plt>
mov    -0x38(%rbp),%rax
cmp    -0x60(%rbp),%rax
je     12f2 <parseAllPostingList+0x1c2>
mov    0x2d08(%rip),%rax
mov    (%rax),%edi
lea    0xd4f(%rip),%rsi
call   1050 <fprintf@plt>
movl   $0x1f,-0x4(%rbp)
jmp    1318 <parseAllPostingList+0x1e8>
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    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<parseAllPostingList>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    $0x1,%eax
cmp    $0x2,%r9
jb     1550 <parseAllPostingList+0x420>
mov    %r8,%r15
mov    %rdx,%r13
mov    %rsi,%r14
mov    %rdi,0x30(%rsp)
mov    %r9,0x38(%rsp)
mov    (%r8),%ebx
mov    0x4(%r8),%eax
add    $0x1,%eax
mov    %eax,(%rcx)
lea    0x0(,%rbx,4),%edi
mov    %rcx,%rbp
call   1040 <myMalloc@plt>
mov    %rax,0x20(%rsp)
lea    0x0(,%rbx,8),%edi
call   1040 <myMalloc@plt>
mov    %rax,0x18(%rsp)
mov    %rbx,0x10(%rsp)
test   %rbx,%rbx
je     14f4 <parseAllPostingList+0x3c4>
mov    %rbp,0x28(%rsp)
mov    %r14,(%rsp)
mov    %r13,0x8(%rsp)
lea    0x4(%r15),%r14
lea    0x34(%r15),%rax
mov    %rax,0x40(%rsp)
mov    $0x2,%ebp
xor    %r13d,%r13d
xor    %r12d,%r12d
jmp    11e2 <parseAllPostingList+0xb2>
nopw   0x0(%rax,%rax,1)
mov    %rcx,%rbp
add    $0x1,%r13
cmp    0x10(%rsp),%r13
je     14d7 <parseAllPostingList+0x3a7>
mov    (%r15,%rbp,4),%ebx
mov    0x20(%rsp),%rax
mov    %ebx,(%rax,%r13,4)
lea    0x0(,%rbx,4),%edi
call   1040 <myMalloc@plt>
lea    0x1(%rbp),%rcx
mov    0x18(%rsp),%rdx
mov    %rax,(%rdx,%r13,8)
test   %rbx,%rbx
je     11d0 <parseAllPostingList+0xa0>
cmp    $0x8,%ebx
jb     1234 <parseAllPostingList+0x104>
lea    (%rbx,%rbp,1),%rdx
lea    (%r14,%rdx,4),%rdx
cmp    %rdx,%rax
jae    12b6 <parseAllPostingList+0x186>
lea    (%rax,%rbx,4),%rdx
lea    (%r14,%rbp,4),%rsi
cmp    %rdx,%rsi
jae    12b6 <parseAllPostingList+0x186>
xor    %edx,%edx
test   $0x1,%bl
jne    1240 <parseAllPostingList+0x110>
mov    %rdx,%rsi
jmp    125f <parseAllPostingList+0x12f>
mov    (%r15,%rcx,4),%esi
add    $0x1,%esi
cmp    %r12d,%esi
cmova  %esi,%r12d
mov    %esi,(%rax,%rdx,4)
mov    %rdx,%rsi
or     $0x1,%rsi
add    $0x1,%rcx
mov    %rcx,%rbp
not    %rdx
add    %rbx,%rdx
je     11d3 <parseAllPostingList+0xa3>
sub    %rsi,%rbx
lea    (%rax,%rsi,4),%rax
add    $0x4,%rax
lea    (%r14,%rcx,4),%rsi
xor    %edx,%edx
nopl   0x0(%rax)
mov    -0x4(%rsi,%rdx,4),%edi
add    $0x1,%edi
mov    %edi,-0x4(%rax,%rdx,4)
cmp    %r12d,%edi
cmovbe %r12d,%edi
mov    (%rsi,%rdx,4),%r12d
add    $0x1,%r12d
mov    %r12d,(%rax,%rdx,4)
cmp    %edi,%r12d
cmovbe %edi,%r12d
add    $0x2,%rdx
cmp    %rdx,%rbx
jne    1280 <parseAllPostingList+0x150>
add    %rdx,%rcx
jmp    11d0 <parseAllPostingList+0xa0>
mov    %ebx,%edx
and    $0xfffffff8,%edx
movd   %r12d,%xmm0
pshufd $0x0,%xmm0,%xmm0
lea    -0x8(%rdx),%rsi
mov    %rsi,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rsi,%rsi
movdqa 0xd21(%rip),%xmm6
pcmpeqd %xmm7,%xmm7
je     14c2 <parseAllPostingList+0x392>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
mov    0x40(%rsp),%rdi
lea    (%rdi,%rbp,4),%rbp
xor    %edi,%edi
movdqa %xmm0,%xmm1
nop
movdqu -0x30(%rbp,%rdi,4),%xmm3
movdqu -0x20(%rbp,%rdi,4),%xmm4
psubd  %xmm7,%xmm3
psubd  %xmm7,%xmm4
movdqu %xmm3,(%rax,%rdi,4)
movdqu %xmm4,0x10(%rax,%rdi,4)
movdqa %xmm0,%xmm5
pxor   %xmm6,%xmm5
movdqa %xmm3,%xmm2
pxor   %xmm6,%xmm2
pcmpgtd %xmm5,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm0,%xmm2
por    %xmm3,%xmm2
movdqa %xmm1,%xmm0
pxor   %xmm6,%xmm0
movdqa %xmm4,%xmm3
pxor   %xmm6,%xmm3
pcmpgtd %xmm0,%xmm3
pand   %xmm3,%xmm4
pandn  %xmm1,%xmm3
por    %xmm4,%xmm3
movdqu -0x10(%rbp,%rdi,4),%xmm1
movdqu 0x0(%rbp,%rdi,4),%xmm4
psubd  %xmm7,%xmm1
psubd  %xmm7,%xmm4
movdqu %xmm1,0x20(%rax,%rdi,4)
movdqu %xmm4,0x30(%rax,%rdi,4)
movdqa %xmm2,%xmm5
pxor   %xmm6,%xmm5
movdqa %xmm1,%xmm0
pxor   %xmm6,%xmm0
pcmpgtd %xmm5,%xmm0
pand   %xmm0,%xmm1
pandn  %xmm2,%xmm0
por    %xmm1,%xmm0
movdqa %xmm3,%xmm2
pxor   %xmm6,%xmm2
movdqa %xmm4,%xmm1
pxor   %xmm6,%xmm1
pcmpgtd %xmm2,%xmm1
pand   %xmm1,%xmm4
pandn  %xmm3,%xmm1
por    %xmm4,%xmm1
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1300 <parseAllPostingList+0x1d0>
test   $0x1,%r8b
je     143f <parseAllPostingList+0x30f>
lea    (%rcx,%rdi,1),%rsi
movdqu (%r15,%rsi,4),%xmm2
movdqu 0x10(%r15,%rsi,4),%xmm3
psubd  %xmm7,%xmm2
psubd  %xmm7,%xmm3
movdqu %xmm2,(%rax,%rdi,4)
movdqu %xmm3,0x10(%rax,%rdi,4)
movdqa %xmm0,%xmm4
pxor   %xmm6,%xmm4
movdqa %xmm2,%xmm5
pxor   %xmm6,%xmm5
pcmpgtd %xmm4,%xmm5
pand   %xmm5,%xmm2
pandn  %xmm0,%xmm5
por    %xmm2,%xmm5
movdqa %xmm1,%xmm0
pxor   %xmm6,%xmm0
movdqa %xmm3,%xmm2
pxor   %xmm6,%xmm2
pcmpgtd %xmm0,%xmm2
pand   %xmm2,%xmm3
pandn  %xmm1,%xmm2
por    %xmm3,%xmm2
movdqa %xmm5,%xmm0
movdqa %xmm2,%xmm1
add    %rdx,%rcx
movdqa %xmm1,%xmm2
pxor   %xmm6,%xmm2
movdqa %xmm0,%xmm3
pxor   %xmm6,%xmm3
pcmpgtd %xmm2,%xmm3
pand   %xmm3,%xmm0
pandn  %xmm1,%xmm3
por    %xmm0,%xmm3
pshufd $0xee,%xmm3,%xmm0
movdqa %xmm3,%xmm1
pxor   %xmm6,%xmm1
movdqa %xmm0,%xmm2
pxor   %xmm6,%xmm2
pcmpgtd %xmm2,%xmm1
pand   %xmm1,%xmm3
pandn  %xmm0,%xmm1
por    %xmm3,%xmm1
pshufd $0x55,%xmm1,%xmm0
movdqa %xmm1,%xmm2
pxor   %xmm6,%xmm2
movdqa %xmm0,%xmm3
pxor   %xmm6,%xmm3
pcmpgtd %xmm3,%xmm2
pand   %xmm2,%xmm1
pandn  %xmm0,%xmm2
por    %xmm1,%xmm2
movd   %xmm2,%r12d
mov    %rcx,%rbp
cmp    %rbx,%rdx
je     11d3 <parseAllPostingList+0xa3>
jmp    1236 <parseAllPostingList+0x106>
xor    %edi,%edi
movdqa %xmm0,%xmm1
test   $0x1,%r8b
jne    13d3 <parseAllPostingList+0x2a3>
jmp    143f <parseAllPostingList+0x30f>
mov    0x28(%rsp),%rax
mov    (%rax),%esi
cmp    %esi,%r12d
jbe    14e9 <parseAllPostingList+0x3b9>
mov    %r12d,(%rax)
mov    %r12d,%esi
mov    0x8(%rsp),%r13
mov    (%rsp),%r14
jmp    14ff <parseAllPostingList+0x3cf>
mov    0x0(%rbp),%esi
mov    $0x2,%ebp
xor    %r12d,%r12d
lea    0xb0a(%rip),%rdi
mov    %r12d,%edx
call   1030 <printf@plt>
cmp    0x38(%rsp),%rbp
jne    1536 <parseAllPostingList+0x406>
mov    0x30(%rsp),%rax
mov    0x10(%rsp),%rcx
mov    %ecx,(%rax)
mov    0x20(%rsp),%rax
mov    %rax,(%r14)
mov    0x18(%rsp),%rax
mov    %rax,0x0(%r13)
xor    %eax,%eax
jmp    1550 <parseAllPostingList+0x420>
mov    0x2aa3(%rip),%rax
mov    (%rax),%edi
lea    0xafa(%rip),%rsi
call   1050 <fprintf@plt>
mov    $0x1f,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [48 x i8] c"\0A **** maxpostSource = %d, maxpostComputed = %d\00"
@stderr = global i32 0
@.str.1 = [37 x i8] c"\0A error in parseAllposting.lists() \0A\00"
define i32 @parseAllPostingList(i32* %0, i32** %1, i32*** %2, i32* %3, i32* %4, i64 %5) {
%7 = alloca i32
%8 = alloca i32*
%9 = alloca i32**
%10 = alloca i32***
%11 = alloca i32*
%12 = alloca i32*
%13 = alloca i64
%14 = alloca i32**
%15 = alloca i32*
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i64
%21 = 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 i64 %5, i64* %13
%22 = load i64, i64* %13
%23 = icmp ult i64 %22, 2
br i1 %23, label %24, label %25
24: ; preds = %6
store i32 1, i32* %7
br label %144
25: ; preds = %6
%26 = load i32*, i32** %12
%27 = getelementptr inbounds i32, i32* %26, i64 0
%28 = load i32, i32* %27
store i32 %28, i32* %16
%29 = load i32*, i32** %12
%30 = getelementptr inbounds i32, i32* %29, i64 1
%31 = load i32, i32* %30
%32 = add i32 %31, 1
%33 = load i32*, i32** %11
store i32 %32, i32* %33
%34 = load i32, i32* %16
%35 = zext i32 %34 to i64
%36 = mul i64 4, %35
%37 = trunc i64 %36 to i32
%38 = call i64 @myMalloc(i32 %37)
%39 = inttoptr i64 %38 to i32*
store i32* %39, i32** %15
%40 = load i32, i32* %16
%41 = zext i32 %40 to i64
%42 = mul i64 8, %41
%43 = trunc i64 %42 to i32
%44 = call i64 @myMalloc(i32 %43)
%45 = inttoptr i64 %44 to i32**
store i32** %45, i32*** %14
store i64 2, i64* %20
store i32 0, i32* %21
store i32 0, i32* %17
br label %46
46: ; preds = %115, %25
%47 = load i32, i32* %17
%48 = load i32, i32* %16
%49 = icmp ult i32 %47, %48
br i1 %49, label %50, label %118
50: ; preds = %46
%51 = load i32*, i32** %12
%52 = load i64, i64* %20
%53 = add i64 %52, 1
store i64 %53, i64* %20
%54 = getelementptr inbounds i32, i32* %51, i64 %52
%55 = load i32, i32* %54
store i32 %55, i32* %19
%56 = load i32*, i32** %15
%57 = load i32, i32* %17
%58 = zext i32 %57 to i64
%59 = getelementptr inbounds i32, i32* %56, i64 %58
store i32 %55, i32* %59
%60 = load i32, i32* %19
%61 = zext i32 %60 to i64
%62 = mul i64 4, %61
%63 = trunc i64 %62 to i32
%64 = call i64 @myMalloc(i32 %63)
%65 = inttoptr i64 %64 to i32*
%66 = load i32**, i32*** %14
%67 = load i32, i32* %17
%68 = zext i32 %67 to i64
%69 = getelementptr inbounds i32*, i32** %66, i64 %68
store i32* %65, i32** %69
store i32 0, i32* %18
br label %70
70: ; preds = %111, %50
%71 = load i32, i32* %18
%72 = load i32, i32* %19
%73 = icmp ult i32 %71, %72
br i1 %73, label %74, label %114
74: ; preds = %70
%75 = load i32*, i32** %12
%76 = load i64, i64* %20
%77 = add i64 %76, 1
store i64 %77, i64* %20
%78 = getelementptr inbounds i32, i32* %75, i64 %76
%79 = load i32, i32* %78
%80 = add i32 1, %79
%81 = load i32**, i32*** %14
%82 = load i32, i32* %17
%83 = zext i32 %82 to i64
%84 = getelementptr inbounds i32*, i32** %81, i64 %83
%85 = load i32*, i32** %84
%86 = load i32, i32* %18
%87 = zext i32 %86 to i64
%88 = getelementptr inbounds i32, i32* %85, i64 %87
store i32 %80, i32* %88
%89 = load i32**, i32*** %14
%90 = load i32, i32* %17
%91 = zext i32 %90 to i64
%92 = getelementptr inbounds i32*, i32** %89, i64 %91
%93 = load i32*, i32** %92
%94 = load i32, i32* %18
%95 = zext i32 %94 to i64
%96 = getelementptr inbounds i32, i32* %93, i64 %95
%97 = load i32, i32* %96
%98 = load i32, i32* %21
%99 = icmp ugt i32 %97, %98
br i1 %99, label %100, label %110
100: ; preds = %74
%101 = load i32**, i32*** %14
%102 = load i32, i32* %17
%103 = zext i32 %102 to i64
%104 = getelementptr inbounds i32*, i32** %101, i64 %103
%105 = load i32*, i32** %104
%106 = load i32, i32* %18
%107 = zext i32 %106 to i64
%108 = getelementptr inbounds i32, i32* %105, i64 %107
%109 = load i32, i32* %108
store i32 %109, i32* %21
br label %110
110: ; preds = %100, %74
br label %111
111: ; preds = %110
%112 = load i32, i32* %18
%113 = add i32 %112, 1
store i32 %113, i32* %18
br label %70
114: ; preds = %70
br label %115
115: ; preds = %114
%116 = load i32, i32* %17
%117 = add i32 %116, 1
store i32 %117, i32* %17
br label %46
118: ; preds = %46
%119 = load i32, i32* %21
%120 = load i32*, i32** %11
%121 = load i32, i32* %120
%122 = icmp ugt i32 %119, %121
br i1 %122, label %123, label %126
123: ; preds = %118
%124 = load i32, i32* %21
%125 = load i32*, i32** %11
store i32 %124, i32* %125
br label %126
126: ; preds = %123, %118
%127 = load i32*, i32** %11
%128 = load i32, i32* %127
%129 = load i32, i32* %21
%130 = call i32 @printf(i8* getelementptr inbounds ([48 x i8], [48 x i8]* @.str, i64 0, i64 0), i32 %128, i32 %129)
%131 = load i64, i64* %13
%132 = load i64, i64* %20
%133 = icmp ne i64 %131, %132
br i1 %133, label %134, label %137
134: ; preds = %126
%135 = load i32, i32* @stderr
%136 = call i32 @fprintf(i32 %135, i8* getelementptr inbounds ([37 x i8], [37 x i8]* @.str.1, i64 0, i64 0))
store i32 31, i32* %7
br label %144
137: ; preds = %126
%138 = load i32, i32* %16
%139 = load i32*, i32** %8
store i32 %138, i32* %139
%140 = load i32*, i32** %15
%141 = load i32**, i32*** %9
store i32* %140, i32** %141
%142 = load i32**, i32*** %14
%143 = load i32***, i32**** %10
store i32** %142, i32*** %143
store i32 0, i32* %7
br label %144
144: ; preds = %137, %134, %24
%145 = load i32, i32* %7
ret i32 %145
}

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