#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__ vrna_alloc(int);
void preparePosteriorBoundaries(int size, int shift, int *min_k, int *max_k,
                                int **min_l, int **max_l) {
  int i;
  *min_k = 10000000;
  *max_k = 0;
  *min_l = (int *)vrna_alloc(sizeof(int) * size);
  *max_l = (int *)vrna_alloc(sizeof(int) * size);
  for (i = 0; i < size; i++) {
    (*min_l)[i] = 10000000;
    (*max_l)[i] = 0;
  }
  *min_l -= shift;
  *max_l -= shift;
}


x86 assembly (clang, -O0):
<preparePosteriorBoundaries>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x10(%rbp),%rax
movl   $0x989680,(%rax)
mov    -0x18(%rbp),%rax
movl   $0x0,(%rax)
movslq -0x4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <vrna_alloc@plt>
mov    %rax,%rcx
mov    -0x20(%rbp),%rax
mov    %rcx,(%rax)
movslq -0x4(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1030 <vrna_alloc@plt>
mov    %rax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    11b9 <preparePosteriorBoundaries+0xa9>
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x2c(%rbp),%rcx
movl   $0x989680,(%rax,%rcx,4)
mov    -0x28(%rbp),%rax
mov    (%rax),%rax
movslq -0x2c(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    117b <preparePosteriorBoundaries+0x6b>
mov    -0x8(%rbp),%edx
mov    -0x20(%rbp),%rax
mov    (%rax),%rcx
movslq %edx,%rsi
xor    %edx,%edx
sub    %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
mov    %rcx,(%rax)
mov    -0x8(%rbp),%edx
mov    -0x28(%rbp),%rax
mov    (%rax),%rcx
movslq %edx,%rsi
xor    %edx,%edx
sub    %rsi,%rdx
shl    $0x2,%rdx
add    %rdx,%rcx
mov    %rcx,(%rax)
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<preparePosteriorBoundaries>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %r9,%r14
mov    %r8,%r12
mov    %esi,%r15d
mov    %edi,%ebp
movl   $0x989680,(%rdx)
movl   $0x0,(%rcx)
lea    0x0(,%rbp,4),%ebx
mov    %ebx,%edi
call   1030 <vrna_alloc@plt>
mov    %rax,(%r12)
mov    %ebx,%edi
call   1030 <vrna_alloc@plt>
mov    %rax,(%r14)
mov    (%r12),%rcx
test   %ebp,%ebp
jle    12e4 <preparePosteriorBoundaries+0x1d4>
mov    %ebp,%r8d
cmp    $0x8,%ebp
jb     1179 <preparePosteriorBoundaries+0x69>
lea    (%rax,%r8,4),%rdx
cmp    %rdx,%rcx
jae    120c <preparePosteriorBoundaries+0xfc>
lea    (%rcx,%r8,4),%rdx
cmp    %rdx,%rax
jae    120c <preparePosteriorBoundaries+0xfc>
xor    %esi,%esi
mov    %rsi,%rdi
not    %rdi
add    %r8,%rdi
mov    %r8,%rdx
and    $0x3,%rdx
je     11a8 <preparePosteriorBoundaries+0x98>
nopl   (%rax)
movl   $0x989680,(%rcx,%rsi,4)
movl   $0x0,(%rax,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdx
jne    1190 <preparePosteriorBoundaries+0x80>
cmp    $0x3,%rdi
jb     12e4 <preparePosteriorBoundaries+0x1d4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movl   $0x989680,(%rcx,%rsi,4)
movl   $0x0,(%rax,%rsi,4)
movl   $0x989680,0x4(%rcx,%rsi,4)
movl   $0x0,0x4(%rax,%rsi,4)
movl   $0x989680,0x8(%rcx,%rsi,4)
movl   $0x0,0x8(%rax,%rsi,4)
movl   $0x989680,0xc(%rcx,%rsi,4)
movl   $0x0,0xc(%rax,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%r8
jne    11c0 <preparePosteriorBoundaries+0xb0>
jmp    12e4 <preparePosteriorBoundaries+0x1d4>
mov    %r8d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rdx
mov    %rdx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%ebp
and    $0x3,%ebp
cmp    $0x18,%rdx
jae    1230 <preparePosteriorBoundaries+0x120>
xor    %ebx,%ebx
jmp    1298 <preparePosteriorBoundaries+0x188>
and    $0xfffffffffffffffc,%rdi
xor    %ebx,%ebx
movaps 0xdc3(%rip),%xmm0
xorps  %xmm1,%xmm1
movups %xmm0,(%rcx,%rbx,4)
movups %xmm0,0x10(%rcx,%rbx,4)
movups %xmm1,(%rax,%rbx,4)
movups %xmm1,0x10(%rax,%rbx,4)
movups %xmm0,0x20(%rcx,%rbx,4)
movups %xmm0,0x30(%rcx,%rbx,4)
movups %xmm1,0x20(%rax,%rbx,4)
movups %xmm1,0x30(%rax,%rbx,4)
movups %xmm0,0x40(%rcx,%rbx,4)
movups %xmm0,0x50(%rcx,%rbx,4)
movups %xmm1,0x40(%rax,%rbx,4)
movups %xmm1,0x50(%rax,%rbx,4)
movups %xmm0,0x60(%rcx,%rbx,4)
movups %xmm0,0x70(%rcx,%rbx,4)
movups %xmm1,0x60(%rax,%rbx,4)
movups %xmm1,0x70(%rax,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%rdi
jne    1240 <preparePosteriorBoundaries+0x130>
test   %rbp,%rbp
je     12db <preparePosteriorBoundaries+0x1cb>
lea    (%rax,%rbx,4),%rdi
add    $0x10,%rdi
lea    (%rcx,%rbx,4),%rbx
add    $0x10,%rbx
shl    $0x5,%rbp
xor    %edx,%edx
movaps 0xd46(%rip),%xmm0
xorps  %xmm1,%xmm1
nopl   (%rax)
movups %xmm0,-0x10(%rbx,%rdx,1)
movups %xmm0,(%rbx,%rdx,1)
movups %xmm1,-0x10(%rdi,%rdx,1)
movups %xmm1,(%rdi,%rdx,1)
add    $0x20,%rdx
cmp    %rdx,%rbp
jne    12c0 <preparePosteriorBoundaries+0x1b0>
cmp    %r8,%rsi
jne    117b <preparePosteriorBoundaries+0x6b>
movslq %r15d,%rax
shl    $0x2,%rax
sub    %rax,%rcx
mov    %rcx,(%r12)
sub    %rax,(%r14)
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @preparePosteriorBoundaries(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
store i32 %0, i32* %7
store i32 %1, i32* %8
store i32* %2, i32** %9
store i32* %3, i32** %10
store i32** %4, i32*** %11
store i32** %5, i32*** %12
%14 = load i32*, i32** %9
store i32 10000000, i32* %14
%15 = load i32*, i32** %10
store i32 0, i32* %15
%16 = load i32, i32* %7
%17 = sext i32 %16 to i64
%18 = mul i64 4, %17
%19 = trunc i64 %18 to i32
%20 = call i64 @vrna_alloc(i32 %19)
%21 = inttoptr i64 %20 to i32*
%22 = load i32**, i32*** %11
store i32* %21, i32** %22
%23 = load i32, i32* %7
%24 = sext i32 %23 to i64
%25 = mul i64 4, %24
%26 = trunc i64 %25 to i32
%27 = call i64 @vrna_alloc(i32 %26)
%28 = inttoptr i64 %27 to i32*
%29 = load i32**, i32*** %12
store i32* %28, i32** %29
store i32 0, i32* %13
br label %30
30: ; preds = %45, %6
%31 = load i32, i32* %13
%32 = load i32, i32* %7
%33 = icmp slt i32 %31, %32
br i1 %33, label %34, label %48
34: ; preds = %30
%35 = load i32**, i32*** %11
%36 = load i32*, i32** %35
%37 = load i32, i32* %13
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds i32, i32* %36, i64 %38
store i32 10000000, i32* %39
%40 = load i32**, i32*** %12
%41 = load i32*, i32** %40
%42 = load i32, i32* %13
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i32, i32* %41, i64 %43
store i32 0, i32* %44
br label %45
45: ; preds = %34
%46 = load i32, i32* %13
%47 = add nsw i32 %46, 1
store i32 %47, i32* %13
br label %30
48: ; preds = %30
%49 = load i32, i32* %8
%50 = load i32**, i32*** %11
%51 = load i32*, i32** %50
%52 = sext i32 %49 to i64
%53 = sub i64 0, %52
%54 = getelementptr inbounds i32, i32* %51, i64 %53
store i32* %54, i32** %50
%55 = load i32, i32* %8
%56 = load i32**, i32*** %12
%57 = load i32*, i32** %56
%58 = sext i32 %55 to i64
%59 = sub i64 0, %58
%60 = getelementptr inbounds i32, i32* %57, i64 %59
store i32* %60, i32** %56
ret void
}

LLVM IR (-O2):
define void @preparePosteriorBoundaries(i32 %0, i32 %1, i32* nocapture writeonly %2, i32* nocapture writeonly %3, i32** nocapture %4, i32** nocapture %5) {
store i32 10000000, i32* %2
store i32 0, i32* %3
%7 = shl i32 %0, 2
%8 = tail call i64 @vrna_alloc(i32 %7)
%9 = inttoptr i64 %8 to i32*
store i32* %9, i32** %4
%10 = tail call i64 @vrna_alloc(i32 %7)
%11 = inttoptr i64 %10 to i32*
%12 = inttoptr i64 %10 to i8*
store i32* %11, i32** %5
%13 = icmp sgt i32 %0, 0
%14 = load i32*, i32** %4
br i1 %13, label %15, label %126
15: ; preds = %6
%16 = zext i32 %0 to i64
%17 = icmp ult i32 %0, 8
br i1 %17, label %94, label %18
18: ; preds = %15
%19 = getelementptr i32, i32* %14, i64 %16
%20 = bitcast i32* %19 to i8*
%21 = getelementptr i32, i32* %11, i64 %16
%22 = icmp ult i32* %14, %21
%23 = icmp ult i8* %12, %20
%24 = and i1 %22, %23
br i1 %24, label %94, label %25
25: ; preds = %18
%26 = and i64 %16, 4294967288
%27 = add nsw i64 %26, -8
%28 = lshr exact i64 %27, 3
%29 = add nuw nsw i64 %28, 1
%30 = and i64 %29, 3
%31 = icmp ult i64 %27, 24
br i1 %31, label %75, label %32
32: ; preds = %25
%33 = and i64 %29, 4611686018427387900
br label %34
34: ; preds = %34, %32
%35 = phi i64 [ 0, %32 ], [ %72, %34 ]
%36 = phi i64 [ 0, %32 ], [ %73, %34 ]
%37 = getelementptr inbounds i32, i32* %14, i64 %35
%38 = bitcast i32* %37 to <4 x i32>*
store <4 x i32> <i32 10000000, i32 10000000, i32 10000000, i32 10000000>, <4 x i32>* %38
%39 = getelementptr inbounds i32, i32* %37, i64 4
%40 = bitcast i32* %39 to <4 x i32>*
store <4 x i32> <i32 10000000, i32 10000000, i32 10000000, i32 10000000>, <4 x i32>* %40
%41 = getelementptr inbounds i32, i32* %11, i64 %35
%42 = bitcast i32* %41 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %42
%43 = getelementptr inbounds i32, i32* %41, i64 4
%44 = bitcast i32* %43 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %44
%45 = or i64 %35, 8
%46 = getelementptr inbounds i32, i32* %14, i64 %45
%47 = bitcast i32* %46 to <4 x i32>*
store <4 x i32> <i32 10000000, i32 10000000, i32 10000000, i32 10000000>, <4 x i32>* %47
%48 = getelementptr inbounds i32, i32* %46, i64 4
%49 = bitcast i32* %48 to <4 x i32>*
store <4 x i32> <i32 10000000, i32 10000000, i32 10000000, i32 10000000>, <4 x i32>* %49
%50 = getelementptr inbounds i32, i32* %11, i64 %45
%51 = bitcast i32* %50 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %51
%52 = getelementptr inbounds i32, i32* %50, i64 4
%53 = bitcast i32* %52 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %53
%54 = or i64 %35, 16
%55 = getelementptr inbounds i32, i32* %14, i64 %54
%56 = bitcast i32* %55 to <4 x i32>*
store <4 x i32> <i32 10000000, i32 10000000, i32 10000000, i32 10000000>, <4 x i32>* %56
%57 = getelementptr inbounds i32, i32* %55, i64 4
%58 = bitcast i32* %57 to <4 x i32>*
store <4 x i32> <i32 10000000, i32 10000000, i32 10000000, i32 10000000>, <4 x i32>* %58
%59 = getelementptr inbounds i32, i32* %11, i64 %54
%60 = bitcast i32* %59 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %60
%61 = getelementptr inbounds i32, i32* %59, i64 4
%62 = bitcast i32* %61 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %62
%63 = or i64 %35, 24
%64 = getelementptr inbounds i32, i32* %14, i64 %63
%65 = bitcast i32* %64 to <4 x i32>*
store <4 x i32> <i32 10000000, i32 10000000, i32 10000000, i32 10000000>, <4 x i32>* %65
%66 = getelementptr inbounds i32, i32* %64, i64 4
%67 = bitcast i32* %66 to <4 x i32>*
store <4 x i32> <i32 10000000, i32 10000000, i32 10000000, i32 10000000>, <4 x i32>* %67
%68 = getelementptr inbounds i32, i32* %11, i64 %63
%69 = bitcast i32* %68 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %69
%70 = getelementptr inbounds i32, i32* %68, i64 4
%71 = bitcast i32* %70 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %71
%72 = add nuw i64 %35, 32
%73 = add i64 %36, 4
%74 = icmp eq i64 %73, %33
br i1 %74, label %75, label %34
75: ; preds = %34, %25
%76 = phi i64 [ 0, %25 ], [ %72, %34 ]
%77 = icmp eq i64 %30, 0
br i1 %77, label %92, label %78
78: ; preds = %75, %78
%79 = phi i64 [ %89, %78 ], [ %76, %75 ]
%80 = phi i64 [ %90, %78 ], [ 0, %75 ]
%81 = getelementptr inbounds i32, i32* %14, i64 %79
%82 = bitcast i32* %81 to <4 x i32>*
store <4 x i32> <i32 10000000, i32 10000000, i32 10000000, i32 10000000>, <4 x i32>* %82
%83 = getelementptr inbounds i32, i32* %81, i64 4
%84 = bitcast i32* %83 to <4 x i32>*
store <4 x i32> <i32 10000000, i32 10000000, i32 10000000, i32 10000000>, <4 x i32>* %84
%85 = getelementptr inbounds i32, i32* %11, i64 %79
%86 = bitcast i32* %85 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %86
%87 = getelementptr inbounds i32, i32* %85, i64 4
%88 = bitcast i32* %87 to <4 x i32>*
store <4 x i32> zeroinitializer, <4 x i32>* %88
%89 = add nuw i64 %79, 8
%90 = add i64 %80, 1
%91 = icmp eq i64 %90, %30
br i1 %91, label %92, label %78
92: ; preds = %78, %75
%93 = icmp eq i64 %26, %16
br i1 %93, label %126, label %94
94: ; preds = %18, %15, %92
%95 = phi i64 [ 0, %18 ], [ 0, %15 ], [ %26, %92 ]
%96 = xor i64 %95, -1
%97 = add nsw i64 %96, %16
%98 = and i64 %16, 3
%99 = icmp eq i64 %98, 0
br i1 %99, label %108, label %100
100: ; preds = %94, %100
%101 = phi i64 [ %105, %100 ], [ %95, %94 ]
%102 = phi i64 [ %106, %100 ], [ 0, %94 ]
%103 = getelementptr inbounds i32, i32* %14, i64 %101
store i32 10000000, i32* %103
%104 = getelementptr inbounds i32, i32* %11, i64 %101
store i32 0, i32* %104
%105 = add nuw nsw i64 %101, 1
%106 = add i64 %102, 1
%107 = icmp eq i64 %106, %98
br i1 %107, label %108, label %100
108: ; preds = %100, %94
%109 = phi i64 [ %95, %94 ], [ %105, %100 ]
%110 = icmp ult i64 %97, 3
br i1 %110, label %126, label %111
111: ; preds = %108, %111
%112 = phi i64 [ %124, %111 ], [ %109, %108 ]
%113 = getelementptr inbounds i32, i32* %14, i64 %112
store i32 10000000, i32* %113
%114 = getelementptr inbounds i32, i32* %11, i64 %112
store i32 0, i32* %114
%115 = add nuw nsw i64 %112, 1
%116 = getelementptr inbounds i32, i32* %14, i64 %115
store i32 10000000, i32* %116
%117 = getelementptr inbounds i32, i32* %11, i64 %115
store i32 0, i32* %117
%118 = add nuw nsw i64 %112, 2
%119 = getelementptr inbounds i32, i32* %14, i64 %118
store i32 10000000, i32* %119
%120 = getelementptr inbounds i32, i32* %11, i64 %118
store i32 0, i32* %120
%121 = add nuw nsw i64 %112, 3
%122 = getelementptr inbounds i32, i32* %14, i64 %121
store i32 10000000, i32* %122
%123 = getelementptr inbounds i32, i32* %11, i64 %121
store i32 0, i32* %123
%124 = add nuw nsw i64 %112, 4
%125 = icmp eq i64 %124, %16
br i1 %125, label %126, label %111
126: ; preds = %108, %111, %92, %6
%127 = sext i32 %1 to i64
%128 = sub nsw i64 0, %127
%129 = getelementptr inbounds i32, i32* %14, i64 %128
store i32* %129, i32** %4
%130 = load i32*, i32** %5
%131 = getelementptr inbounds i32, i32* %130, i64 %128
store i32* %131, i32** %5
ret void
}