long long int merge(int arr[], int temp[], int left, int mid, int right) {
  int i, j, k;
  long long int inv_count = 0;
  i = left;
  j = mid;
  k = left;
  while ((i <= mid - 1) && (j <= right)) {
    if (arr[i] <= arr[j]) {
      temp[k++] = arr[i++];
    } else {
      temp[k++] = arr[j++];
      inv_count = inv_count + (mid - i);
    }
  }
  while (i <= mid - 1)
    temp[k++] = arr[i++];
  while (j <= right)
    temp[k++] = arr[j++];
  for (i = left; i <= right; i++)
    arr[i] = temp[i];
  return inv_count;
}


x86 assembly (clang, -O0):
<merge>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
movq   $0x0,-0x30(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%edx
sub    $0x1,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x31(%rbp)
jg     1152 <merge+0x52>
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setle  %al
mov    %al,-0x31(%rbp)
mov    -0x31(%rbp),%al
test   $0x1,%al
jne    1162 <merge+0x62>
jmp    11f0 <merge+0xf0>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0x24(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     11ad <merge+0xad>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x20(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    11eb <merge+0xeb>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%rax
mov    -0x18(%rbp),%ecx
sub    -0x20(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
jmp    1130 <merge+0x30>
jmp    11f5 <merge+0xf5>
mov    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1235 <merge+0x135>
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x20(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    11f5 <merge+0xf5>
jmp    123a <merge+0x13a>
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1275 <merge+0x175>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    123a <merge+0x13a>
mov    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     12ab <merge+0x1ab>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    127b <merge+0x17b>
mov    -0x30(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<merge>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
xor    %eax,%eax
mov    %edx,%r11d
mov    %ecx,%r9d
mov    %edx,%r10d
cmp    %ecx,%edx
jge    1179 <merge+0x79>
cmp    %r8d,%ecx
jg     1179 <merge+0x79>
movslq %edx,%rax
lea    (%rsi,%rax,4),%rbx
xor    %eax,%eax
mov    %edx,%r10d
mov    %ecx,%r9d
mov    %edx,%r11d
movslq %r11d,%rbp
mov    (%rdi,%rbp,4),%r15d
movslq %r9d,%rbp
mov    (%rdi,%rbp,4),%r14d
cmp    %r14d,%r15d
jle    1160 <merge+0x60>
add    $0x1,%r9d
mov    %ecx,%ebp
sub    %r11d,%ebp
movslq %ebp,%rbp
add    %rbp,%rax
mov    %r14d,%r15d
jmp    1164 <merge+0x64>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r11d
mov    %r15d,(%rbx)
add    $0x1,%r10d
cmp    %ecx,%r11d
jge    1179 <merge+0x79>
add    $0x4,%rbx
cmp    %r8d,%r9d
jle    1130 <merge+0x30>
cmp    %ecx,%r11d
jge    12ef <merge+0x1ef>
movslq %r10d,%r10
movslq %r11d,%r13
movslq %ecx,%r11
mov    %r11,%r14
sub    %r13,%r14
cmp    $0x8,%r14
jb     126c <merge+0x16c>
lea    (%rsi,%r10,4),%rbx
lea    (%rdi,%r11,4),%rbp
cmp    %rbp,%rbx
jae    11c0 <merge+0xc0>
lea    (%r10,%r11,1),%rbx
sub    %r13,%rbx
lea    (%rsi,%rbx,4),%rbx
lea    (%rdi,%r13,4),%rbp
cmp    %rbx,%rbp
jb     126c <merge+0x16c>
mov    %r14,%r15
and    $0xfffffffffffffff8,%r15
lea    -0x8(%r15),%rbx
mov    %rbx,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rbx,%rbx
mov    %r15,-0x8(%rsp)
mov    %rbp,-0x10(%rsp)
je     1611 <merge+0x511>
and    $0xfffffffffffffffe,%rbp
lea    (%rdi,%r13,4),%r15
add    $0x30,%r15
lea    (%rsi,%r10,4),%r12
add    $0x30,%r12
xor    %ebx,%ebx
nop
movups -0x30(%r15,%rbx,4),%xmm0
movups -0x20(%r15,%rbx,4),%xmm1
movups %xmm0,-0x30(%r12,%rbx,4)
movups %xmm1,-0x20(%r12,%rbx,4)
movups -0x10(%r15,%rbx,4),%xmm0
movups (%r15,%rbx,4),%xmm1
movups %xmm0,-0x10(%r12,%rbx,4)
movups %xmm1,(%r12,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rbp
jne    1200 <merge+0x100>
testb  $0x1,-0x10(%rsp)
je     1258 <merge+0x158>
lea    (%rbx,%r13,1),%rbp
add    %r10,%rbx
movups (%rdi,%rbp,4),%xmm0
movups 0x10(%rdi,%rbp,4),%xmm1
movups %xmm0,(%rsi,%rbx,4)
movups %xmm1,0x10(%rsi,%rbx,4)
mov    -0x8(%rsp),%rbx
add    %rbx,%r10
cmp    %rbx,%r14
je     12ef <merge+0x1ef>
add    %rbx,%r13
sub    %r13d,%ecx
mov    %r13,%rbx
not    %rbx
add    %r11,%rbx
and    $0x3,%rcx
je     1296 <merge+0x196>
xchg   %ax,%ax
mov    (%rdi,%r13,4),%ebp
add    $0x1,%r13
mov    %ebp,(%rsi,%r10,4)
add    $0x1,%r10
add    $0xffffffffffffffff,%rcx
jne    1280 <merge+0x180>
cmp    $0x3,%rbx
jb     12ef <merge+0x1ef>
sub    %r13,%r11
lea    (%rdi,%r13,4),%r14
add    $0xc,%r14
lea    (%rsi,%r10,4),%rbp
add    $0xc,%rbp
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0xc(%r14,%rcx,4),%ebx
mov    %ebx,-0xc(%rbp,%rcx,4)
mov    -0x8(%r14,%rcx,4),%ebx
mov    %ebx,-0x8(%rbp,%rcx,4)
mov    -0x4(%r14,%rcx,4),%ebx
mov    %ebx,-0x4(%rbp,%rcx,4)
mov    (%r14,%rcx,4),%ebx
mov    %ebx,0x0(%rbp,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r11
jne    12c0 <merge+0x1c0>
add    %rcx,%r10
cmp    %r8d,%r9d
jg     146b <merge+0x36b>
movslq %r10d,%r14
movslq %r9d,%rbx
mov    %r8d,%r10d
sub    %r9d,%r10d
cmp    $0x7,%r10d
jb     13e6 <merge+0x2e6>
lea    (%rsi,%r14,4),%rcx
lea    (%rbx,%r10,1),%rbp
lea    (%rdi,%rbp,4),%rbp
add    $0x4,%rbp
cmp    %rbp,%rcx
jae    133c <merge+0x23c>
lea    (%r14,%r10,1),%rcx
lea    (%rsi,%rcx,4),%rcx
add    $0x4,%rcx
lea    (%rdi,%rbx,4),%rbp
cmp    %rcx,%rbp
jb     13e6 <merge+0x2e6>
add    $0x1,%r10
mov    %r10,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rcx
mov    %rcx,%r11
shr    $0x3,%r11
add    $0x1,%r11
test   %rcx,%rcx
je     1623 <merge+0x523>
mov    %r11,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%rdi,%rbx,4),%r15
add    $0x30,%r15
lea    (%rsi,%r14,4),%r12
add    $0x30,%r12
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movups -0x30(%r15,%rcx,4),%xmm0
movups -0x20(%r15,%rcx,4),%xmm1
movups %xmm0,-0x30(%r12,%rcx,4)
movups %xmm1,-0x20(%r12,%rcx,4)
movups -0x10(%r15,%rcx,4),%xmm0
movups (%r15,%rcx,4),%xmm1
movups %xmm0,-0x10(%r12,%rcx,4)
movups %xmm1,(%r12,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rbp
jne    1380 <merge+0x280>
test   $0x1,%r11b
je     13d7 <merge+0x2d7>
lea    (%rcx,%rbx,1),%rbp
add    %r14,%rcx
movups (%rdi,%rbp,4),%xmm0
movups 0x10(%rdi,%rbp,4),%xmm1
movups %xmm0,(%rsi,%rcx,4)
movups %xmm1,0x10(%rsi,%rcx,4)
cmp    %r9,%r10
je     146b <merge+0x36b>
add    %r9,%rbx
add    %r9,%r14
mov    %r8d,%r9d
sub    %ebx,%r9d
lea    0x1(%r9),%ebp
and    $0x3,%ebp
je     1414 <merge+0x314>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rdi,%rbx,4),%ecx
add    $0x1,%rbx
mov    %ecx,(%rsi,%r14,4)
add    $0x1,%r14
add    $0xffffffff,%ebp
jne    1400 <merge+0x300>
cmp    $0x3,%r9d
jb     146b <merge+0x36b>
mov    %r8d,%r9d
sub    %ebx,%r9d
add    $0x1,%r9d
lea    (%rdi,%rbx,4),%r10
add    $0xc,%r10
lea    (%rsi,%r14,4),%rbx
add    $0xc,%rbx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
mov    -0xc(%r10,%rcx,4),%ebp
mov    %ebp,-0xc(%rbx,%rcx,4)
mov    -0x8(%r10,%rcx,4),%ebp
mov    %ebp,-0x8(%rbx,%rcx,4)
mov    -0x4(%r10,%rcx,4),%ebp
mov    %ebp,-0x4(%rbx,%rcx,4)
mov    (%r10,%rcx,4),%ebp
mov    %ebp,(%rbx,%rcx,4)
add    $0x4,%rcx
cmp    %ecx,%r9d
jne    1440 <merge+0x340>
mov    %r8d,%r11d
sub    %edx,%r11d
jl     1606 <merge+0x506>
movslq %edx,%rcx
cmp    $0x7,%r11d
jb     15a3 <merge+0x4a3>
lea    (%rdi,%rcx,4),%rbp
lea    (%r11,%rcx,1),%rdx
lea    (%rsi,%rdx,4),%rbx
add    $0x4,%rbx
cmp    %rbx,%rbp
jae    14ae <merge+0x3ae>
lea    (%rdi,%rdx,4),%rdx
add    $0x4,%rdx
lea    (%rsi,%rcx,4),%rbp
cmp    %rdx,%rbp
jb     15a3 <merge+0x4a3>
add    $0x1,%r11
mov    %r11,%r9
and    $0xfffffffffffffff8,%r9
lea    -0x8(%r9),%rdx
mov    %rdx,%r14
shr    $0x3,%r14
add    $0x1,%r14
mov    %r14d,%r10d
and    $0x3,%r10d
cmp    $0x18,%rdx
jae    14dc <merge+0x3dc>
xor    %ebx,%ebx
jmp    1560 <merge+0x460>
movabs $0x3ffffffffffffffe,%rdx
ff ff 3f
add    $0xfffffffffffffffe,%rdx
and    %rdx,%r14
lea    (%rdi,%rcx,4),%r15
add    $0x70,%r15
lea    (%rsi,%rcx,4),%rdx
add    $0x70,%rdx
xor    %ebx,%ebx
nop
movups -0x70(%rdx,%rbx,4),%xmm0
movups -0x60(%rdx,%rbx,4),%xmm1
movups %xmm0,-0x70(%r15,%rbx,4)
movups %xmm1,-0x60(%r15,%rbx,4)
movups -0x50(%rdx,%rbx,4),%xmm0
movups -0x40(%rdx,%rbx,4),%xmm1
movups %xmm0,-0x50(%r15,%rbx,4)
movups %xmm1,-0x40(%r15,%rbx,4)
movups -0x30(%rdx,%rbx,4),%xmm0
movups -0x20(%rdx,%rbx,4),%xmm1
movups %xmm0,-0x30(%r15,%rbx,4)
movups %xmm1,-0x20(%r15,%rbx,4)
movups -0x10(%rdx,%rbx,4),%xmm0
movups (%rdx,%rbx,4),%xmm1
movups %xmm0,-0x10(%r15,%rbx,4)
movups %xmm1,(%r15,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%r14
jne    1500 <merge+0x400>
test   %r10,%r10
je     159b <merge+0x49b>
add    %rcx,%rbx
lea    (%rdi,%rbx,4),%rdx
add    $0x10,%rdx
lea    (%rsi,%rbx,4),%rbx
add    $0x10,%rbx
shl    $0x5,%r10
xor    %ebp,%ebp
xchg   %ax,%ax
movups -0x10(%rbx,%rbp,1),%xmm0
movups (%rbx,%rbp,1),%xmm1
movups %xmm0,-0x10(%rdx,%rbp,1)
movups %xmm1,(%rdx,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r10
jne    1580 <merge+0x480>
cmp    %r9,%r11
je     1606 <merge+0x506>
add    %r9,%rcx
lea    0x1(%r8),%ebp
mov    %ebp,%edx
sub    %ecx,%edx
sub    %ecx,%r8d
and    $0x3,%edx
je     15cf <merge+0x4cf>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%rsi,%rcx,4),%ebx
mov    %ebx,(%rdi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffff,%edx
jne    15c0 <merge+0x4c0>
cmp    $0x3,%r8d
jb     1606 <merge+0x506>
mov    %ebp,%edx
nopw   0x0(%rax,%rax,1)
mov    (%rsi,%rcx,4),%ebp
mov    %ebp,(%rdi,%rcx,4)
mov    0x4(%rsi,%rcx,4),%ebp
mov    %ebp,0x4(%rdi,%rcx,4)
mov    0x8(%rsi,%rcx,4),%ebp
mov    %ebp,0x8(%rdi,%rcx,4)
mov    0xc(%rsi,%rcx,4),%ebp
mov    %ebp,0xc(%rdi,%rcx,4)
add    $0x4,%rcx
cmp    %ecx,%edx
jne    15e0 <merge+0x4e0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebx,%ebx
testb  $0x1,-0x10(%rsp)
jne    123f <merge+0x13f>
jmp    1258 <merge+0x158>
xor    %ecx,%ecx
test   $0x1,%r11b
jne    13be <merge+0x2be>
jmp    13d7 <merge+0x2d7>

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

LLVM IR (-O2):
define i64 @merge(i32* nocapture %0, i32* nocapture %1, i32 %2, i32 %3, i32 %4) {
%6 = icmp slt i32 %2, %3
%7 = icmp sle i32 %3, %4
%8 = and i1 %6, %7
br i1 %8, label %9, label %13
9: ; preds = %5
%10 = sext i32 %2 to i64
br label %119
11: ; preds = %138
%12 = trunc i64 %144 to i32
br label %13
13: ; preds = %11, %5
%14 = phi i32 [ %2, %5 ], [ %140, %11 ]
%15 = phi i32 [ %3, %5 ], [ %141, %11 ]
%16 = phi i32 [ %2, %5 ], [ %12, %11 ]
%17 = phi i64 [ 0, %5 ], [ %142, %11 ]
%18 = icmp slt i32 %14, %3
br i1 %18, label %19, label %151
19: ; preds = %13
%20 = sext i32 %16 to i64
%21 = sext i32 %14 to i64
%22 = sext i32 %3 to i64
%23 = sub nsw i64 %22, %21
%24 = icmp ult i64 %23, 8
br i1 %24, label %95, label %25
25: ; preds = %19
%26 = getelementptr i32, i32* %1, i64 %20
%27 = add nsw i64 %20, %22
%28 = sub nsw i64 %27, %21
%29 = getelementptr i32, i32* %1, i64 %28
%30 = getelementptr i32, i32* %0, i64 %21
%31 = getelementptr i32, i32* %0, i64 %22
%32 = icmp ult i32* %26, %31
%33 = icmp ult i32* %30, %29
%34 = and i1 %32, %33
br i1 %34, label %95, label %35
35: ; preds = %25
%36 = and i64 %23, -8
%37 = add nsw i64 %36, %21
%38 = add nsw i64 %36, %20
%39 = add nsw i64 %36, -8
%40 = lshr exact i64 %39, 3
%41 = add nuw nsw i64 %40, 1
%42 = and i64 %41, 1
%43 = icmp eq i64 %39, 0
br i1 %43, label %77, label %44
44: ; preds = %35
%45 = and i64 %41, 4611686018427387902
br label %46
46: ; preds = %46, %44
%47 = phi i64 [ 0, %44 ], [ %74, %46 ]
%48 = phi i64 [ 0, %44 ], [ %75, %46 ]
%49 = add i64 %47, %21
%50 = add i64 %47, %20
%51 = getelementptr inbounds i32, i32* %0, i64 %49
%52 = bitcast i32* %51 to <4 x i32>*
%53 = load <4 x i32>, <4 x i32>* %52
%54 = getelementptr inbounds i32, i32* %51, i64 4
%55 = bitcast i32* %54 to <4 x i32>*
%56 = load <4 x i32>, <4 x i32>* %55
%57 = getelementptr inbounds i32, i32* %1, i64 %50
%58 = bitcast i32* %57 to <4 x i32>*
store <4 x i32> %53, <4 x i32>* %58
%59 = getelementptr inbounds i32, i32* %57, i64 4
%60 = bitcast i32* %59 to <4 x i32>*
store <4 x i32> %56, <4 x i32>* %60
%61 = or i64 %47, 8
%62 = add i64 %61, %21
%63 = add i64 %61, %20
%64 = getelementptr inbounds i32, i32* %0, i64 %62
%65 = bitcast i32* %64 to <4 x i32>*
%66 = load <4 x i32>, <4 x i32>* %65
%67 = getelementptr inbounds i32, i32* %64, i64 4
%68 = bitcast i32* %67 to <4 x i32>*
%69 = load <4 x i32>, <4 x i32>* %68
%70 = getelementptr inbounds i32, i32* %1, i64 %63
%71 = bitcast i32* %70 to <4 x i32>*
store <4 x i32> %66, <4 x i32>* %71
%72 = getelementptr inbounds i32, i32* %70, i64 4
%73 = bitcast i32* %72 to <4 x i32>*
store <4 x i32> %69, <4 x i32>* %73
%74 = add nuw i64 %47, 16
%75 = add i64 %48, 2
%76 = icmp eq i64 %75, %45
br i1 %76, label %77, label %46
77: ; preds = %46, %35
%78 = phi i64 [ 0, %35 ], [ %74, %46 ]
%79 = icmp eq i64 %42, 0
br i1 %79, label %93, label %80
80: ; preds = %77
%81 = add i64 %78, %21
%82 = add i64 %78, %20
%83 = getelementptr inbounds i32, i32* %0, i64 %81
%84 = bitcast i32* %83 to <4 x i32>*
%85 = load <4 x i32>, <4 x i32>* %84
%86 = getelementptr inbounds i32, i32* %83, i64 4
%87 = bitcast i32* %86 to <4 x i32>*
%88 = load <4 x i32>, <4 x i32>* %87
%89 = getelementptr inbounds i32, i32* %1, i64 %82
%90 = bitcast i32* %89 to <4 x i32>*
store <4 x i32> %85, <4 x i32>* %90
%91 = getelementptr inbounds i32, i32* %89, i64 4
%92 = bitcast i32* %91 to <4 x i32>*
store <4 x i32> %88, <4 x i32>* %92
br label %93
93: ; preds = %77, %80
%94 = icmp eq i64 %23, %36
br i1 %94, label %148, label %95
95: ; preds = %25, %19, %93
%96 = phi i64 [ %21, %25 ], [ %21, %19 ], [ %37, %93 ]
%97 = phi i64 [ %20, %25 ], [ %20, %19 ], [ %38, %93 ]
%98 = sub nsw i64 %22, %96
%99 = xor i64 %96, -1
%100 = add nsw i64 %99, %22
%101 = and i64 %98, 3
%102 = icmp eq i64 %101, 0
br i1 %102, label %114, label %103
103: ; preds = %95, %103
%104 = phi i64 [ %107, %103 ], [ %96, %95 ]
%105 = phi i64 [ %110, %103 ], [ %97, %95 ]
%106 = phi i64 [ %112, %103 ], [ 0, %95 ]
%107 = add nsw i64 %104, 1
%108 = getelementptr inbounds i32, i32* %0, i64 %104
%109 = load i32, i32* %108
%110 = add nsw i64 %105, 1
%111 = getelementptr inbounds i32, i32* %1, i64 %105
store i32 %109, i32* %111
%112 = add i64 %106, 1
%113 = icmp eq i64 %112, %101
br i1 %113, label %114, label %103
114: ; preds = %103, %95
%115 = phi i64 [ undef, %95 ], [ %110, %103 ]
%116 = phi i64 [ %96, %95 ], [ %107, %103 ]
%117 = phi i64 [ %97, %95 ], [ %110, %103 ]
%118 = icmp ult i64 %100, 3
br i1 %118, label %148, label %260
119: ; preds = %9, %138
%120 = phi i64 [ %10, %9 ], [ %144, %138 ]
%121 = phi i64 [ 0, %9 ], [ %142, %138 ]
%122 = phi i32 [ %3, %9 ], [ %141, %138 ]
%123 = phi i32 [ %2, %9 ], [ %140, %138 ]
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds i32, i32* %0, i64 %124
%126 = load i32, i32* %125
%127 = sext i32 %122 to i64
%128 = getelementptr inbounds i32, i32* %0, i64 %127
%129 = load i32, i32* %128
%130 = icmp sgt i32 %126, %129
br i1 %130, label %133, label %131
131: ; preds = %119
%132 = add nsw i32 %123, 1
br label %138
133: ; preds = %119
%134 = add nsw i32 %122, 1
%135 = sub nsw i32 %3, %123
%136 = sext i32 %135 to i64
%137 = add nsw i64 %121, %136
br label %138
138: ; preds = %133, %131
%139 = phi i32 [ %129, %133 ], [ %126, %131 ]
%140 = phi i32 [ %123, %133 ], [ %132, %131 ]
%141 = phi i32 [ %134, %133 ], [ %122, %131 ]
%142 = phi i64 [ %137, %133 ], [ %121, %131 ]
%143 = getelementptr inbounds i32, i32* %1, i64 %120
store i32 %139, i32* %143
%144 = add i64 %120, 1
%145 = icmp slt i32 %140, %3
%146 = icmp sle i32 %141, %4
%147 = select i1 %145, i1 %146, i1 false
br i1 %147, label %119, label %11
148: ; preds = %114, %260, %93
%149 = phi i64 [ %38, %93 ], [ %115, %114 ], [ %281, %260 ]
%150 = trunc i64 %149 to i32
br label %151
151: ; preds = %148, %13
%152 = phi i32 [ %16, %13 ], [ %150, %148 ]
%153 = icmp sgt i32 %15, %4
br i1 %153, label %284, label %154
154: ; preds = %151
%155 = sext i32 %152 to i64
%156 = sext i32 %15 to i64
%157 = add i32 %4, 1
%158 = sub i32 %4, %15
%159 = zext i32 %158 to i64
%160 = add nuw nsw i64 %159, 1
%161 = icmp ult i32 %158, 7
br i1 %161, label %236, label %162
162: ; preds = %154
%163 = getelementptr i32, i32* %1, i64 %155
%164 = sub i32 %4, %15
%165 = zext i32 %164 to i64
%166 = add nsw i64 %155, %165
%167 = add nsw i64 %166, 1
%168 = getelementptr i32, i32* %1, i64 %167
%169 = getelementptr i32, i32* %0, i64 %156
%170 = add nsw i64 %156, %165
%171 = add nsw i64 %170, 1
%172 = getelementptr i32, i32* %0, i64 %171
%173 = icmp ult i32* %163, %172
%174 = icmp ult i32* %169, %168
%175 = and i1 %173, %174
br i1 %175, label %236, label %176
176: ; preds = %162
%177 = and i64 %160, 8589934584
%178 = add nsw i64 %177, %156
%179 = add nsw i64 %177, %155
%180 = add nsw i64 %177, -8
%181 = lshr exact i64 %180, 3
%182 = add nuw nsw i64 %181, 1
%183 = and i64 %182, 1
%184 = icmp eq i64 %180, 0
br i1 %184, label %218, label %185
185: ; preds = %176
%186 = and i64 %182, 4611686018427387902
br label %187
187: ; preds = %187, %185
%188 = phi i64 [ 0, %185 ], [ %215, %187 ]
%189 = phi i64 [ 0, %185 ], [ %216, %187 ]
%190 = add i64 %188, %156
%191 = add i64 %188, %155
%192 = getelementptr inbounds i32, i32* %0, i64 %190
%193 = bitcast i32* %192 to <4 x i32>*
%194 = load <4 x i32>, <4 x i32>* %193
%195 = getelementptr inbounds i32, i32* %192, i64 4
%196 = bitcast i32* %195 to <4 x i32>*
%197 = load <4 x i32>, <4 x i32>* %196
%198 = getelementptr inbounds i32, i32* %1, i64 %191
%199 = bitcast i32* %198 to <4 x i32>*
store <4 x i32> %194, <4 x i32>* %199
%200 = getelementptr inbounds i32, i32* %198, i64 4
%201 = bitcast i32* %200 to <4 x i32>*
store <4 x i32> %197, <4 x i32>* %201
%202 = or i64 %188, 8
%203 = add i64 %202, %156
%204 = add i64 %202, %155
%205 = getelementptr inbounds i32, i32* %0, i64 %203
%206 = bitcast i32* %205 to <4 x i32>*
%207 = load <4 x i32>, <4 x i32>* %206
%208 = getelementptr inbounds i32, i32* %205, i64 4
%209 = bitcast i32* %208 to <4 x i32>*
%210 = load <4 x i32>, <4 x i32>* %209
%211 = getelementptr inbounds i32, i32* %1, i64 %204
%212 = bitcast i32* %211 to <4 x i32>*
store <4 x i32> %207, <4 x i32>* %212
%213 = getelementptr inbounds i32, i32* %211, i64 4
%214 = bitcast i32* %213 to <4 x i32>*
store <4 x i32> %210, <4 x i32>* %214
%215 = add nuw i64 %188, 16
%216 = add i64 %189, 2
%217 = icmp eq i64 %216, %186
br i1 %217, label %218, label %187
218: ; preds = %187, %176
%219 = phi i64 [ 0, %176 ], [ %215, %187 ]
%220 = icmp eq i64 %183, 0
br i1 %220, label %234, label %221
221: ; preds = %218
%222 = add i64 %219, %156
%223 = add i64 %219, %155
%224 = getelementptr inbounds i32, i32* %0, i64 %222
%225 = bitcast i32* %224 to <4 x i32>*
%226 = load <4 x i32>, <4 x i32>* %225
%227 = getelementptr inbounds i32, i32* %224, i64 4
%228 = bitcast i32* %227 to <4 x i32>*
%229 = load <4 x i32>, <4 x i32>* %228
%230 = getelementptr inbounds i32, i32* %1, i64 %223
%231 = bitcast i32* %230 to <4 x i32>*
store <4 x i32> %226, <4 x i32>* %231
%232 = getelementptr inbounds i32, i32* %230, i64 4
%233 = bitcast i32* %232 to <4 x i32>*
store <4 x i32> %229, <4 x i32>* %233
br label %234
234: ; preds = %218, %221
%235 = icmp eq i64 %160, %177
br i1 %235, label %284, label %236
236: ; preds = %162, %154, %234
%237 = phi i64 [ %156, %162 ], [ %156, %154 ], [ %178, %234 ]
%238 = phi i64 [ %155, %162 ], [ %155, %154 ], [ %179, %234 ]
%239 = add i32 %4, 1
%240 = trunc i64 %237 to i32
%241 = sub i32 %239, %240
%242 = sub i32 %4, %240
%243 = and i32 %241, 3
%244 = icmp eq i32 %243, 0
br i1 %244, label %256, label %245
245: ; preds = %236, %245
%246 = phi i64 [ %249, %245 ], [ %237, %236 ]
%247 = phi i64 [ %252, %245 ], [ %238, %236 ]
%248 = phi i32 [ %254, %245 ], [ 0, %236 ]
%249 = add nsw i64 %246, 1
%250 = getelementptr inbounds i32, i32* %0, i64 %246
%251 = load i32, i32* %250
%252 = add nsw i64 %247, 1
%253 = getelementptr inbounds i32, i32* %1, i64 %247
store i32 %251, i32* %253
%254 = add i32 %248, 1
%255 = icmp eq i32 %254, %243
br i1 %255, label %256, label %245
256: ; preds = %245, %236
%257 = phi i64 [ %237, %236 ], [ %249, %245 ]
%258 = phi i64 [ %238, %236 ], [ %252, %245 ]
%259 = icmp ult i32 %242, 3
br i1 %259, label %284, label %410
260: ; preds = %114, %260
%261 = phi i64 [ %278, %260 ], [ %116, %114 ]
%262 = phi i64 [ %281, %260 ], [ %117, %114 ]
%263 = add nsw i64 %261, 1
%264 = getelementptr inbounds i32, i32* %0, i64 %261
%265 = load i32, i32* %264
%266 = add nsw i64 %262, 1
%267 = getelementptr inbounds i32, i32* %1, i64 %262
store i32 %265, i32* %267
%268 = add nsw i64 %261, 2
%269 = getelementptr inbounds i32, i32* %0, i64 %263
%270 = load i32, i32* %269
%271 = add nsw i64 %262, 2
%272 = getelementptr inbounds i32, i32* %1, i64 %266
store i32 %270, i32* %272
%273 = add nsw i64 %261, 3
%274 = getelementptr inbounds i32, i32* %0, i64 %268
%275 = load i32, i32* %274
%276 = add nsw i64 %262, 3
%277 = getelementptr inbounds i32, i32* %1, i64 %271
store i32 %275, i32* %277
%278 = add nsw i64 %261, 4
%279 = getelementptr inbounds i32, i32* %0, i64 %273
%280 = load i32, i32* %279
%281 = add nsw i64 %262, 4
%282 = getelementptr inbounds i32, i32* %1, i64 %276
store i32 %280, i32* %282
%283 = icmp eq i64 %278, %22
br i1 %283, label %148, label %260
284: ; preds = %256, %410, %234, %151
%285 = icmp slt i32 %4, %2
br i1 %285, label %455, label %286
286: ; preds = %284
%287 = sext i32 %2 to i64
%288 = add i32 %4, 1
%289 = sub i32 %4, %2
%290 = zext i32 %289 to i64
%291 = add nuw nsw i64 %290, 1
%292 = icmp ult i32 %289, 7
br i1 %292, label %390, label %293
293: ; preds = %286
%294 = getelementptr i32, i32* %0, i64 %287
%295 = sub i32 %4, %2
%296 = zext i32 %295 to i64
%297 = add nsw i64 %287, %296
%298 = add nsw i64 %297, 1
%299 = getelementptr i32, i32* %0, i64 %298
%300 = getelementptr i32, i32* %1, i64 %287
%301 = getelementptr i32, i32* %1, i64 %298
%302 = icmp ult i32* %294, %301
%303 = icmp ult i32* %300, %299
%304 = and i1 %302, %303
br i1 %304, label %390, label %305
305: ; preds = %293
%306 = and i64 %291, 8589934584
%307 = add nsw i64 %306, %287
%308 = add nsw i64 %306, -8
%309 = lshr exact i64 %308, 3
%310 = add nuw nsw i64 %309, 1
%311 = and i64 %310, 3
%312 = icmp ult i64 %308, 24
br i1 %312, label %368, label %313
313: ; preds = %305
%314 = and i64 %310, 4611686018427387900
br label %315
315: ; preds = %315, %313
%316 = phi i64 [ 0, %313 ], [ %365, %315 ]
%317 = phi i64 [ 0, %313 ], [ %366, %315 ]
%318 = add i64 %316, %287
%319 = getelementptr inbounds i32, i32* %1, i64 %318
%320 = bitcast i32* %319 to <4 x i32>*
%321 = load <4 x i32>, <4 x i32>* %320
%322 = getelementptr inbounds i32, i32* %319, i64 4
%323 = bitcast i32* %322 to <4 x i32>*
%324 = load <4 x i32>, <4 x i32>* %323
%325 = getelementptr inbounds i32, i32* %0, i64 %318
%326 = bitcast i32* %325 to <4 x i32>*
store <4 x i32> %321, <4 x i32>* %326
%327 = getelementptr inbounds i32, i32* %325, i64 4
%328 = bitcast i32* %327 to <4 x i32>*
store <4 x i32> %324, <4 x i32>* %328
%329 = or i64 %316, 8
%330 = add i64 %329, %287
%331 = getelementptr inbounds i32, i32* %1, i64 %330
%332 = bitcast i32* %331 to <4 x i32>*
%333 = load <4 x i32>, <4 x i32>* %332
%334 = getelementptr inbounds i32, i32* %331, i64 4
%335 = bitcast i32* %334 to <4 x i32>*
%336 = load <4 x i32>, <4 x i32>* %335
%337 = getelementptr inbounds i32, i32* %0, i64 %330
%338 = bitcast i32* %337 to <4 x i32>*
store <4 x i32> %333, <4 x i32>* %338
%339 = getelementptr inbounds i32, i32* %337, i64 4
%340 = bitcast i32* %339 to <4 x i32>*
store <4 x i32> %336, <4 x i32>* %340
%341 = or i64 %316, 16
%342 = add i64 %341, %287
%343 = getelementptr inbounds i32, i32* %1, i64 %342
%344 = bitcast i32* %343 to <4 x i32>*
%345 = load <4 x i32>, <4 x i32>* %344
%346 = getelementptr inbounds i32, i32* %343, i64 4
%347 = bitcast i32* %346 to <4 x i32>*
%348 = load <4 x i32>, <4 x i32>* %347
%349 = getelementptr inbounds i32, i32* %0, i64 %342
%350 = bitcast i32* %349 to <4 x i32>*
store <4 x i32> %345, <4 x i32>* %350
%351 = getelementptr inbounds i32, i32* %349, i64 4
%352 = bitcast i32* %351 to <4 x i32>*
store <4 x i32> %348, <4 x i32>* %352
%353 = or i64 %316, 24
%354 = add i64 %353, %287
%355 = getelementptr inbounds i32, i32* %1, i64 %354
%356 = bitcast i32* %355 to <4 x i32>*
%357 = load <4 x i32>, <4 x i32>* %356
%358 = getelementptr inbounds i32, i32* %355, i64 4
%359 = bitcast i32* %358 to <4 x i32>*
%360 = load <4 x i32>, <4 x i32>* %359
%361 = getelementptr inbounds i32, i32* %0, i64 %354
%362 = bitcast i32* %361 to <4 x i32>*
store <4 x i32> %357, <4 x i32>* %362
%363 = getelementptr inbounds i32, i32* %361, i64 4
%364 = bitcast i32* %363 to <4 x i32>*
store <4 x i32> %360, <4 x i32>* %364
%365 = add nuw i64 %316, 32
%366 = add i64 %317, 4
%367 = icmp eq i64 %366, %314
br i1 %367, label %368, label %315
368: ; preds = %315, %305
%369 = phi i64 [ 0, %305 ], [ %365, %315 ]
%370 = icmp eq i64 %311, 0
br i1 %370, label %388, label %371
371: ; preds = %368, %371
%372 = phi i64 [ %385, %371 ], [ %369, %368 ]
%373 = phi i64 [ %386, %371 ], [ 0, %368 ]
%374 = add i64 %372, %287
%375 = getelementptr inbounds i32, i32* %1, i64 %374
%376 = bitcast i32* %375 to <4 x i32>*
%377 = load <4 x i32>, <4 x i32>* %376
%378 = getelementptr inbounds i32, i32* %375, i64 4
%379 = bitcast i32* %378 to <4 x i32>*
%380 = load <4 x i32>, <4 x i32>* %379
%381 = getelementptr inbounds i32, i32* %0, i64 %374
%382 = bitcast i32* %381 to <4 x i32>*
store <4 x i32> %377, <4 x i32>* %382
%383 = getelementptr inbounds i32, i32* %381, i64 4
%384 = bitcast i32* %383 to <4 x i32>*
store <4 x i32> %380, <4 x i32>* %384
%385 = add nuw i64 %372, 8
%386 = add i64 %373, 1
%387 = icmp eq i64 %386, %311
br i1 %387, label %388, label %371
388: ; preds = %371, %368
%389 = icmp eq i64 %291, %306
br i1 %389, label %455, label %390
390: ; preds = %293, %286, %388
%391 = phi i64 [ %287, %293 ], [ %287, %286 ], [ %307, %388 ]
%392 = add i32 %4, 1
%393 = trunc i64 %391 to i32
%394 = sub i32 %392, %393
%395 = sub i32 %4, %393
%396 = and i32 %394, 3
%397 = icmp eq i32 %396, 0
br i1 %397, label %407, label %398
398: ; preds = %390, %398
%399 = phi i64 [ %404, %398 ], [ %391, %390 ]
%400 = phi i32 [ %405, %398 ], [ 0, %390 ]
%401 = getelementptr inbounds i32, i32* %1, i64 %399
%402 = load i32, i32* %401
%403 = getelementptr inbounds i32, i32* %0, i64 %399
store i32 %402, i32* %403
%404 = add nsw i64 %399, 1
%405 = add i32 %400, 1
%406 = icmp eq i32 %405, %396
br i1 %406, label %407, label %398
407: ; preds = %398, %390
%408 = phi i64 [ %391, %390 ], [ %404, %398 ]
%409 = icmp ult i32 %395, 3
br i1 %409, label %455, label %435
410: ; preds = %256, %410
%411 = phi i64 [ %428, %410 ], [ %257, %256 ]
%412 = phi i64 [ %431, %410 ], [ %258, %256 ]
%413 = add nsw i64 %411, 1
%414 = getelementptr inbounds i32, i32* %0, i64 %411
%415 = load i32, i32* %414
%416 = add nsw i64 %412, 1
%417 = getelementptr inbounds i32, i32* %1, i64 %412
store i32 %415, i32* %417
%418 = add nsw i64 %411, 2
%419 = getelementptr inbounds i32, i32* %0, i64 %413
%420 = load i32, i32* %419
%421 = add nsw i64 %412, 2
%422 = getelementptr inbounds i32, i32* %1, i64 %416
store i32 %420, i32* %422
%423 = add nsw i64 %411, 3
%424 = getelementptr inbounds i32, i32* %0, i64 %418
%425 = load i32, i32* %424
%426 = add nsw i64 %412, 3
%427 = getelementptr inbounds i32, i32* %1, i64 %421
store i32 %425, i32* %427
%428 = add nsw i64 %411, 4
%429 = getelementptr inbounds i32, i32* %0, i64 %423
%430 = load i32, i32* %429
%431 = add nsw i64 %412, 4
%432 = getelementptr inbounds i32, i32* %1, i64 %426
store i32 %430, i32* %432
%433 = trunc i64 %428 to i32
%434 = icmp eq i32 %157, %433
br i1 %434, label %284, label %410
435: ; preds = %407, %435
%436 = phi i64 [ %452, %435 ], [ %408, %407 ]
%437 = getelementptr inbounds i32, i32* %1, i64 %436
%438 = load i32, i32* %437
%439 = getelementptr inbounds i32, i32* %0, i64 %436
store i32 %438, i32* %439
%440 = add nsw i64 %436, 1
%441 = getelementptr inbounds i32, i32* %1, i64 %440
%442 = load i32, i32* %441
%443 = getelementptr inbounds i32, i32* %0, i64 %440
store i32 %442, i32* %443
%444 = add nsw i64 %436, 2
%445 = getelementptr inbounds i32, i32* %1, i64 %444
%446 = load i32, i32* %445
%447 = getelementptr inbounds i32, i32* %0, i64 %444
store i32 %446, i32* %447
%448 = add nsw i64 %436, 3
%449 = getelementptr inbounds i32, i32* %1, i64 %448
%450 = load i32, i32* %449
%451 = getelementptr inbounds i32, i32* %0, i64 %448
store i32 %450, i32* %451
%452 = add nsw i64 %436, 4
%453 = trunc i64 %452 to i32
%454 = icmp eq i32 %288, %453
br i1 %454, label %455, label %435
455: ; preds = %407, %435, %388, %284
ret i64 %17
}