#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*/ free(int *);
int *malloc(int);
void sort_merge(int *array, int size) {
  int rs, ls, i, j, k;
  int *left, *right;
  if (size < 2)
    return;
  ls = size / 2;
  rs = size - ls;
  left = malloc(sizeof(int) * ls);
  right = malloc(sizeof(int) * rs);
  for (i = k = 0; i < ls; i++, k++)
    left[i] = array[k];
  for (j = 0; j < rs; j++, k++)
    right[j] = array[k];
  sort_merge(left, ls);
  sort_merge(right, rs);
  for (i = j = k = 0; i < ls && j < rs; k++) {
    if (left[i] <= right[j])
      array[k] = left[i++];
    else
      array[k] = right[j++];
  }
  while (i < ls)
    array[k++] = left[i++];
  while (j < rs)
    array[k++] = right[j++];
  free(left);
  free(right);
}


x86 assembly (clang, -O0):
<sort_merge>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
cmpl   $0x2,-0xc(%rbp)
jge    114e <sort_merge+0x1e>
jmp    1372 <sort_merge+0x242>
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x14(%rbp)
mov    -0xc(%rbp),%eax
sub    -0x14(%rbp),%eax
mov    %eax,-0x10(%rbp)
movslq -0x14(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x28(%rbp)
movslq -0x10(%rbp),%rax
shl    $0x2,%rax
mov    %eax,%edi
call   1050 <malloc@plt>
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11d2 <sort_merge+0xa2>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x28(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1199 <sort_merge+0x69>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1212 <sort_merge+0xe2>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x30(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11d9 <sort_merge+0xa9>
mov    -0x28(%rbp),%rdi
mov    -0x14(%rbp),%esi
call   1040 <sort_merge@plt>
mov    -0x30(%rbp),%rdi
mov    -0x10(%rbp),%esi
call   1040 <sort_merge@plt>
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%ecx
xor    %eax,%eax
cmp    -0x14(%rbp),%ecx
mov    %al,-0x31(%rbp)
jge    125c <sort_merge+0x12c>
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
setl   %al
mov    %al,-0x31(%rbp)
mov    -0x31(%rbp),%al
test   $0x1,%al
jne    126c <sort_merge+0x13c>
jmp    12e0 <sort_merge+0x1b0>
mov    -0x28(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x30(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     12ad <sort_merge+0x17d>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    12cd <sort_merge+0x19d>
mov    -0x30(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x1c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
jmp    12d2 <sort_merge+0x1a2>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    123f <sort_merge+0x10f>
jmp    12e5 <sort_merge+0x1b5>
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1320 <sort_merge+0x1f0>
mov    -0x28(%rbp),%rax
mov    -0x18(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x18(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    12e5 <sort_merge+0x1b5>
jmp    1325 <sort_merge+0x1f5>
mov    -0x1c(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1360 <sort_merge+0x230>
mov    -0x30(%rbp),%rax
mov    -0x1c(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x1c(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x20(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1325 <sort_merge+0x1f5>
mov    -0x28(%rbp),%rdi
call   1030 <free@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<sort_merge>:
cmp    $0x2,%esi
jge    1146 <sort_merge+0x6>
ret
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x28,%rsp
mov    %esi,%ebp
mov    %rdi,%r14
mov    %esi,%r13d
shr    %r13d
mov    %esi,%ebx
sub    %r13d,%ebx
lea    0x0(,%r13,4),%edi
call   1060 <malloc@plt>
mov    %rax,%r12
lea    0x0(,%rbx,4),%edi
call   1060 <malloc@plt>
mov    %rax,%r15
lea    0x0(,%r13,4),%rdx
mov    %r12,%rdi
mov    %r14,%rsi
call   1050 <memcpy@plt>
mov    %r13d,%eax
test   %ebx,%ebx
mov    %r12,(%rsp)
mov    %ebp,0xc(%rsp)
mov    %rax,0x20(%rsp)
jle    122c <sort_merge+0xec>
lea    (%r14,%rax,4),%rsi
mov    %r13d,%eax
not    %eax
add    %ebp,%eax
lea    0x4(,%rax,4),%rdx
mov    %r15,%rdi
call   1050 <memcpy@plt>
mov    %r12,%rdi
mov    %r13d,%esi
call   1040 <sort_merge@plt>
mov    %r15,%rdi
mov    %ebx,%esi
call   1040 <sort_merge@plt>
mov    %rbx,%r8
mov    %r15,%rbx
xor    %r15d,%r15d
xor    %eax,%eax
mov    %r14,%rbp
xor    %r14d,%r14d
nop
mov    %r14d,%ecx
mov    %eax,%edx
mov    %eax,%eax
mov    (%r12,%rax,4),%esi
mov    %r14d,%eax
mov    (%rbx,%rax,4),%edi
xor    %eax,%eax
xor    %r14d,%r14d
cmp    %edi,%esi
setle  %al
setg   %r14b
cmovg  %edi,%esi
add    %ecx,%r14d
add    %edx,%eax
mov    %esi,0x0(%rbp,%r15,4)
add    $0x1,%r15
cmp    %r13d,%eax
jae    1252 <sort_merge+0x112>
cmp    %r8d,%r14d
jl     11f0 <sort_merge+0xb0>
jmp    1252 <sort_merge+0x112>
mov    %r12,%rdi
mov    %r13d,%esi
call   1040 <sort_merge@plt>
mov    %r15,%rdi
mov    %ebx,%esi
call   1040 <sort_merge@plt>
mov    %rbx,%r8
mov    %r15,%rbx
xor    %r15d,%r15d
mov    %r14,%rbp
xor    %r14d,%r14d
xor    %eax,%eax
mov    %rbx,0x18(%rsp)
cmp    %r13d,%eax
jge    12b1 <sort_merge+0x171>
mov    %r8,0x10(%rsp)
mov    %r15d,%r15d
mov    %rbp,%rbx
lea    0x0(,%r15,4),%rdi
add    %rbp,%rdi
movslq %eax,%r12
mov    (%rsp),%rcx
lea    (%rcx,%r12,4),%rsi
not    %eax
add    %r13d,%eax
lea    0x4(,%rax,4),%rdx
call   1050 <memcpy@plt>
mov    0x20(%rsp),%r9
mov    %r9,%rax
sub    %r12,%rax
cmp    $0x4,%rax
jae    12ba <sort_merge+0x17a>
mov    (%rsp),%rdi
mov    %rbx,%rbp
mov    0x10(%rsp),%r8
jmp    1358 <sort_merge+0x218>
mov    (%rsp),%rdi
jmp    136c <sort_merge+0x22c>
mov    %rax,%rcx
and    $0xfffffffffffffffc,%rcx
movd   %r15d,%xmm0
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x7,%edx
cmp    $0x1c,%rdi
mov    (%rsp),%rdi
mov    %rbx,%rbp
mov    0x10(%rsp),%r8
jae    12f2 <sort_merge+0x1b2>
pxor   %xmm1,%xmm1
jmp    131e <sort_merge+0x1de>
and    $0xfffffffffffffff8,%rsi
pxor   %xmm1,%xmm1
movdqa 0xcfe(%rip),%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
paddq  %xmm2,%xmm0
paddq  %xmm2,%xmm1
add    $0xfffffffffffffff8,%rsi
jne    1310 <sort_merge+0x1d0>
test   %rdx,%rdx
je     133e <sort_merge+0x1fe>
pcmpeqd %xmm2,%xmm2
nopw   0x0(%rax,%rax,1)
psubq  %xmm2,%xmm0
psubq  %xmm2,%xmm1
add    $0xffffffffffffffff,%rdx
jne    1330 <sort_merge+0x1f0>
paddq  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddq  %xmm0,%xmm1
movq   %xmm1,%r15
cmp    %rcx,%rax
je     136c <sort_merge+0x22c>
add    %rcx,%r12
sub    %r9,%r12
xor    %eax,%eax
nopl   (%rax)
add    $0xffffffffffffffff,%rax
cmp    %rax,%r12
jne    1360 <sort_merge+0x220>
sub    %rax,%r15
cmp    %r8d,%r14d
jge    13a7 <sort_merge+0x267>
mov    %r15d,%eax
lea    0x0(,%rax,4),%rdi
add    %rbp,%rdi
movslq %r14d,%rax
mov    0x18(%rsp),%rcx
lea    (%rcx,%rax,4),%rsi
not    %r14d
add    0xc(%rsp),%r14d
sub    %r13d,%r14d
lea    0x4(,%r14,4),%rdx
call   1050 <memcpy@plt>
mov    (%rsp),%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdi
add    $0x28,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

LLVM IR (-O0):
define void @sort_merge(i32* %0, i32 %1) {
%3 = alloca i32*
%4 = alloca i32
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32*
%11 = alloca i32*
store i32* %0, i32** %3
store i32 %1, i32* %4
%12 = load i32, i32* %4
%13 = icmp slt i32 %12, 2
br i1 %13, label %14, label %15
14: ; preds = %2
br label %162
15: ; preds = %2
%16 = load i32, i32* %4
%17 = sdiv i32 %16, 2
store i32 %17, i32* %6
%18 = load i32, i32* %4
%19 = load i32, i32* %6
%20 = sub nsw i32 %18, %19
store i32 %20, i32* %5
%21 = load i32, i32* %6
%22 = sext i32 %21 to i64
%23 = mul i64 4, %22
%24 = trunc i64 %23 to i32
%25 = call i32* @malloc(i32 %24)
store i32* %25, i32** %10
%26 = load i32, i32* %5
%27 = sext i32 %26 to i64
%28 = mul i64 4, %27
%29 = trunc i64 %28 to i32
%30 = call i32* @malloc(i32 %29)
store i32* %30, i32** %11
store i32 0, i32* %9
store i32 0, i32* %7
br label %31
31: ; preds = %45, %15
%32 = load i32, i32* %7
%33 = load i32, i32* %6
%34 = icmp slt i32 %32, %33
br i1 %34, label %35, label %50
35: ; preds = %31
%36 = load i32*, i32** %3
%37 = load i32, i32* %9
%38 = sext i32 %37 to i64
%39 = getelementptr inbounds i32, i32* %36, i64 %38
%40 = load i32, i32* %39
%41 = load i32*, i32** %10
%42 = load i32, i32* %7
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i32, i32* %41, i64 %43
store i32 %40, i32* %44
br label %45
45: ; preds = %35
%46 = load i32, i32* %7
%47 = add nsw i32 %46, 1
store i32 %47, i32* %7
%48 = load i32, i32* %9
%49 = add nsw i32 %48, 1
store i32 %49, i32* %9
br label %31
50: ; preds = %31
store i32 0, i32* %8
br label %51
51: ; preds = %65, %50
%52 = load i32, i32* %8
%53 = load i32, i32* %5
%54 = icmp slt i32 %52, %53
br i1 %54, label %55, label %70
55: ; preds = %51
%56 = load i32*, i32** %3
%57 = load i32, i32* %9
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds i32, i32* %56, i64 %58
%60 = load i32, i32* %59
%61 = load i32*, i32** %11
%62 = load i32, i32* %8
%63 = sext i32 %62 to i64
%64 = getelementptr inbounds i32, i32* %61, i64 %63
store i32 %60, i32* %64
br label %65
65: ; preds = %55
%66 = load i32, i32* %8
%67 = add nsw i32 %66, 1
store i32 %67, i32* %8
%68 = load i32, i32* %9
%69 = add nsw i32 %68, 1
store i32 %69, i32* %9
br label %51
70: ; preds = %51
%71 = load i32*, i32** %10
%72 = load i32, i32* %6
%73 = load i32*, i32** %11
%74 = load i32, i32* %5
store i32 0, i32* %9
store i32 0, i32* %8
store i32 0, i32* %7
br label %75
75: ; preds = %120, %70
%76 = load i32, i32* %7
%77 = load i32, i32* %6
%78 = icmp slt i32 %76, %77
br i1 %78, label %79, label %83
79: ; preds = %75
%80 = load i32, i32* %8
%81 = load i32, i32* %5
%82 = icmp slt i32 %80, %81
br label %83
83: ; preds = %79, %75
%84 = phi i1 [ false, %75 ], [ %82, %79 ]
br i1 %84, label %85, label %123
85: ; preds = %83
%86 = load i32*, i32** %10
%87 = load i32, i32* %7
%88 = sext i32 %87 to i64
%89 = getelementptr inbounds i32, i32* %86, i64 %88
%90 = load i32, i32* %89
%91 = load i32*, i32** %11
%92 = load i32, i32* %8
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds i32, i32* %91, i64 %93
%95 = load i32, i32* %94
%96 = icmp sle i32 %90, %95
br i1 %96, label %97, label %108
97: ; preds = %85
%98 = load i32*, i32** %10
%99 = load i32, i32* %7
%100 = add nsw i32 %99, 1
store i32 %100, i32* %7
%101 = sext i32 %99 to i64
%102 = getelementptr inbounds i32, i32* %98, i64 %101
%103 = load i32, i32* %102
%104 = load i32*, i32** %3
%105 = load i32, i32* %9
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds i32, i32* %104, i64 %106
store i32 %103, i32* %107
br label %119
108: ; preds = %85
%109 = load i32*, i32** %11
%110 = load i32, i32* %8
%111 = add nsw i32 %110, 1
store i32 %111, i32* %8
%112 = sext i32 %110 to i64
%113 = getelementptr inbounds i32, i32* %109, i64 %112
%114 = load i32, i32* %113
%115 = load i32*, i32** %3
%116 = load i32, i32* %9
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds i32, i32* %115, i64 %117
store i32 %114, i32* %118
br label %119
119: ; preds = %108, %97
br label %120
120: ; preds = %119
%121 = load i32, i32* %9
%122 = add nsw i32 %121, 1
store i32 %122, i32* %9
br label %75
123: ; preds = %83
br label %124
124: ; preds = %128, %123
%125 = load i32, i32* %7
%126 = load i32, i32* %6
%127 = icmp slt i32 %125, %126
br i1 %127, label %128, label %140
128: ; preds = %124
%129 = load i32*, i32** %10
%130 = load i32, i32* %7
%131 = add nsw i32 %130, 1
store i32 %131, i32* %7
%132 = sext i32 %130 to i64
%133 = getelementptr inbounds i32, i32* %129, i64 %132
%134 = load i32, i32* %133
%135 = load i32*, i32** %3
%136 = load i32, i32* %9
%137 = add nsw i32 %136, 1
store i32 %137, i32* %9
%138 = sext i32 %136 to i64
%139 = getelementptr inbounds i32, i32* %135, i64 %138
store i32 %134, i32* %139
br label %124
140: ; preds = %124
br label %141
141: ; preds = %145, %140
%142 = load i32, i32* %8
%143 = load i32, i32* %5
%144 = icmp slt i32 %142, %143
br i1 %144, label %145, label %157
145: ; preds = %141
%146 = load i32*, i32** %11
%147 = load i32, i32* %8
%148 = add nsw i32 %147, 1
store i32 %148, i32* %8
%149 = sext i32 %147 to i64
%150 = getelementptr inbounds i32, i32* %146, i64 %149
%151 = load i32, i32* %150
%152 = load i32*, i32** %3
%153 = load i32, i32* %9
%154 = add nsw i32 %153, 1
store i32 %154, i32* %9
%155 = sext i32 %153 to i64
%156 = getelementptr inbounds i32, i32* %152, i64 %155
store i32 %151, i32* %156
br label %141
157: ; preds = %141
%158 = load i32*, i32** %10
%159 = call i32 @free(i32* %158)
%160 = load i32*, i32** %11
%161 = call i32 @free(i32* %160)
br label %162
162: ; preds = %157, %14
ret void
}

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