int merge(int arr[], int temp[], int left, int mid, int right) {
  int i, j, k;
  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)
movl   $0x0,-0x2c(%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,-0x2d(%rbp)
jg     1151 <merge+0x51>
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setle  %al
mov    %al,-0x2d(%rbp)
mov    -0x2d(%rbp),%al
test   $0x1,%al
jne    1161 <merge+0x61>
jmp    11e9 <merge+0xe9>
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     11ac <merge+0xac>
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    11e4 <merge+0xe4>
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    -0x2c(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    -0x20(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x2c(%rbp)
jmp    112f <merge+0x2f>
jmp    11ee <merge+0xee>
mov    -0x20(%rbp),%eax
mov    -0x18(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     122e <merge+0x12e>
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    11ee <merge+0xee>
jmp    1233 <merge+0x133>
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     126e <merge+0x16e>
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    1233 <merge+0x133>
mov    -0x14(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     12a4 <merge+0x1a4>
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    1274 <merge+0x174>
mov    -0x2c(%rbp),%eax
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
add    %ebp,%eax
mov    %r14d,%r15d
jmp    1164 <merge+0x64>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
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 i32 @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 i32
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 i32 0, i32* %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 = %70, %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 %71
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 %70
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 i32, i32* %14
%66 = load i32, i32* %9
%67 = load i32, i32* %11
%68 = sub nsw i32 %66, %67
%69 = add nsw i32 %65, %68
store i32 %69, i32* %14
br label %70
70: ; preds = %53, %41
br label %18
71: ; preds = %27
br label %72
72: ; preds = %77, %71
%73 = load i32, i32* %11
%74 = load i32, i32* %9
%75 = sub nsw i32 %74, 1
%76 = icmp sle i32 %73, %75
br i1 %76, label %77, label %89
77: ; preds = %72
%78 = load i32*, i32** %6
%79 = load i32, i32* %11
%80 = add nsw i32 %79, 1
store i32 %80, i32* %11
%81 = sext i32 %79 to i64
%82 = getelementptr inbounds i32, i32* %78, i64 %81
%83 = load i32, i32* %82
%84 = load i32*, i32** %7
%85 = load i32, i32* %13
%86 = add nsw i32 %85, 1
store i32 %86, i32* %13
%87 = sext i32 %85 to i64
%88 = getelementptr inbounds i32, i32* %84, i64 %87
store i32 %83, i32* %88
br label %72
89: ; preds = %72
br label %90
90: ; preds = %94, %89
%91 = load i32, i32* %12
%92 = load i32, i32* %10
%93 = icmp sle i32 %91, %92
br i1 %93, label %94, label %106
94: ; preds = %90
%95 = load i32*, i32** %6
%96 = load i32, i32* %12
%97 = add nsw i32 %96, 1
store i32 %97, i32* %12
%98 = sext i32 %96 to i64
%99 = getelementptr inbounds i32, i32* %95, i64 %98
%100 = load i32, i32* %99
%101 = load i32*, i32** %7
%102 = load i32, i32* %13
%103 = add nsw i32 %102, 1
store i32 %103, i32* %13
%104 = sext i32 %102 to i64
%105 = getelementptr inbounds i32, i32* %101, i64 %104
store i32 %100, i32* %105
br label %90
106: ; preds = %90
%107 = load i32, i32* %8
store i32 %107, i32* %11
br label %108
108: ; preds = %122, %106
%109 = load i32, i32* %11
%110 = load i32, i32* %10
%111 = icmp sle i32 %109, %110
br i1 %111, label %112, label %125
112: ; preds = %108
%113 = load i32*, i32** %7
%114 = load i32, i32* %11
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds i32, i32* %113, i64 %115
%117 = load i32, i32* %116
%118 = load i32*, i32** %6
%119 = load i32, i32* %11
%120 = sext i32 %119 to i64
%121 = getelementptr inbounds i32, i32* %118, i64 %120
store i32 %117, i32* %121
br label %122
122: ; preds = %112
%123 = load i32, i32* %11
%124 = add nsw i32 %123, 1
store i32 %124, i32* %11
br label %108
125: ; preds = %108
%126 = load i32, i32* %14
ret i32 %126
}

LLVM IR (-O2):
define i32 @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 = %137
%12 = trunc i64 %143 to i32
br label %13
13: ; preds = %11, %5
%14 = phi i32 [ %2, %5 ], [ %139, %11 ]
%15 = phi i32 [ %3, %5 ], [ %140, %11 ]
%16 = phi i32 [ %2, %5 ], [ %12, %11 ]
%17 = phi i32 [ 0, %5 ], [ %141, %11 ]
%18 = icmp slt i32 %14, %3
br i1 %18, label %19, label %150
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 %147, 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 %147, label %259
119: ; preds = %9, %137
%120 = phi i64 [ %10, %9 ], [ %143, %137 ]
%121 = phi i32 [ 0, %9 ], [ %141, %137 ]
%122 = phi i32 [ %3, %9 ], [ %140, %137 ]
%123 = phi i32 [ %2, %9 ], [ %139, %137 ]
%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 %137
133: ; preds = %119
%134 = add nsw i32 %122, 1
%135 = sub i32 %3, %123
%136 = add nsw i32 %135, %121
br label %137
137: ; preds = %133, %131
%138 = phi i32 [ %129, %133 ], [ %126, %131 ]
%139 = phi i32 [ %123, %133 ], [ %132, %131 ]
%140 = phi i32 [ %134, %133 ], [ %122, %131 ]
%141 = phi i32 [ %136, %133 ], [ %121, %131 ]
%142 = getelementptr inbounds i32, i32* %1, i64 %120
store i32 %138, i32* %142
%143 = add i64 %120, 1
%144 = icmp slt i32 %139, %3
%145 = icmp sle i32 %140, %4
%146 = select i1 %144, i1 %145, i1 false
br i1 %146, label %119, label %11
147: ; preds = %114, %259, %93
%148 = phi i64 [ %38, %93 ], [ %115, %114 ], [ %280, %259 ]
%149 = trunc i64 %148 to i32
br label %150
150: ; preds = %147, %13
%151 = phi i32 [ %16, %13 ], [ %149, %147 ]
%152 = icmp sgt i32 %15, %4
br i1 %152, label %283, label %153
153: ; preds = %150
%154 = sext i32 %151 to i64
%155 = sext i32 %15 to i64
%156 = add i32 %4, 1
%157 = sub i32 %4, %15
%158 = zext i32 %157 to i64
%159 = add nuw nsw i64 %158, 1
%160 = icmp ult i32 %157, 7
br i1 %160, label %235, label %161
161: ; preds = %153
%162 = getelementptr i32, i32* %1, i64 %154
%163 = sub i32 %4, %15
%164 = zext i32 %163 to i64
%165 = add nsw i64 %154, %164
%166 = add nsw i64 %165, 1
%167 = getelementptr i32, i32* %1, i64 %166
%168 = getelementptr i32, i32* %0, i64 %155
%169 = add nsw i64 %155, %164
%170 = add nsw i64 %169, 1
%171 = getelementptr i32, i32* %0, i64 %170
%172 = icmp ult i32* %162, %171
%173 = icmp ult i32* %168, %167
%174 = and i1 %172, %173
br i1 %174, label %235, label %175
175: ; preds = %161
%176 = and i64 %159, 8589934584
%177 = add nsw i64 %176, %155
%178 = add nsw i64 %176, %154
%179 = add nsw i64 %176, -8
%180 = lshr exact i64 %179, 3
%181 = add nuw nsw i64 %180, 1
%182 = and i64 %181, 1
%183 = icmp eq i64 %179, 0
br i1 %183, label %217, label %184
184: ; preds = %175
%185 = and i64 %181, 4611686018427387902
br label %186
186: ; preds = %186, %184
%187 = phi i64 [ 0, %184 ], [ %214, %186 ]
%188 = phi i64 [ 0, %184 ], [ %215, %186 ]
%189 = add i64 %187, %155
%190 = add i64 %187, %154
%191 = getelementptr inbounds i32, i32* %0, i64 %189
%192 = bitcast i32* %191 to <4 x i32>*
%193 = load <4 x i32>, <4 x i32>* %192
%194 = getelementptr inbounds i32, i32* %191, i64 4
%195 = bitcast i32* %194 to <4 x i32>*
%196 = load <4 x i32>, <4 x i32>* %195
%197 = getelementptr inbounds i32, i32* %1, i64 %190
%198 = bitcast i32* %197 to <4 x i32>*
store <4 x i32> %193, <4 x i32>* %198
%199 = getelementptr inbounds i32, i32* %197, i64 4
%200 = bitcast i32* %199 to <4 x i32>*
store <4 x i32> %196, <4 x i32>* %200
%201 = or i64 %187, 8
%202 = add i64 %201, %155
%203 = add i64 %201, %154
%204 = getelementptr inbounds i32, i32* %0, i64 %202
%205 = bitcast i32* %204 to <4 x i32>*
%206 = load <4 x i32>, <4 x i32>* %205
%207 = getelementptr inbounds i32, i32* %204, i64 4
%208 = bitcast i32* %207 to <4 x i32>*
%209 = load <4 x i32>, <4 x i32>* %208
%210 = getelementptr inbounds i32, i32* %1, i64 %203
%211 = bitcast i32* %210 to <4 x i32>*
store <4 x i32> %206, <4 x i32>* %211
%212 = getelementptr inbounds i32, i32* %210, i64 4
%213 = bitcast i32* %212 to <4 x i32>*
store <4 x i32> %209, <4 x i32>* %213
%214 = add nuw i64 %187, 16
%215 = add i64 %188, 2
%216 = icmp eq i64 %215, %185
br i1 %216, label %217, label %186
217: ; preds = %186, %175
%218 = phi i64 [ 0, %175 ], [ %214, %186 ]
%219 = icmp eq i64 %182, 0
br i1 %219, label %233, label %220
220: ; preds = %217
%221 = add i64 %218, %155
%222 = add i64 %218, %154
%223 = getelementptr inbounds i32, i32* %0, i64 %221
%224 = bitcast i32* %223 to <4 x i32>*
%225 = load <4 x i32>, <4 x i32>* %224
%226 = getelementptr inbounds i32, i32* %223, i64 4
%227 = bitcast i32* %226 to <4 x i32>*
%228 = load <4 x i32>, <4 x i32>* %227
%229 = getelementptr inbounds i32, i32* %1, i64 %222
%230 = bitcast i32* %229 to <4 x i32>*
store <4 x i32> %225, <4 x i32>* %230
%231 = getelementptr inbounds i32, i32* %229, i64 4
%232 = bitcast i32* %231 to <4 x i32>*
store <4 x i32> %228, <4 x i32>* %232
br label %233
233: ; preds = %217, %220
%234 = icmp eq i64 %159, %176
br i1 %234, label %283, label %235
235: ; preds = %161, %153, %233
%236 = phi i64 [ %155, %161 ], [ %155, %153 ], [ %177, %233 ]
%237 = phi i64 [ %154, %161 ], [ %154, %153 ], [ %178, %233 ]
%238 = add i32 %4, 1
%239 = trunc i64 %236 to i32
%240 = sub i32 %238, %239
%241 = sub i32 %4, %239
%242 = and i32 %240, 3
%243 = icmp eq i32 %242, 0
br i1 %243, label %255, label %244
244: ; preds = %235, %244
%245 = phi i64 [ %248, %244 ], [ %236, %235 ]
%246 = phi i64 [ %251, %244 ], [ %237, %235 ]
%247 = phi i32 [ %253, %244 ], [ 0, %235 ]
%248 = add nsw i64 %245, 1
%249 = getelementptr inbounds i32, i32* %0, i64 %245
%250 = load i32, i32* %249
%251 = add nsw i64 %246, 1
%252 = getelementptr inbounds i32, i32* %1, i64 %246
store i32 %250, i32* %252
%253 = add i32 %247, 1
%254 = icmp eq i32 %253, %242
br i1 %254, label %255, label %244
255: ; preds = %244, %235
%256 = phi i64 [ %236, %235 ], [ %248, %244 ]
%257 = phi i64 [ %237, %235 ], [ %251, %244 ]
%258 = icmp ult i32 %241, 3
br i1 %258, label %283, label %409
259: ; preds = %114, %259
%260 = phi i64 [ %277, %259 ], [ %116, %114 ]
%261 = phi i64 [ %280, %259 ], [ %117, %114 ]
%262 = add nsw i64 %260, 1
%263 = getelementptr inbounds i32, i32* %0, i64 %260
%264 = load i32, i32* %263
%265 = add nsw i64 %261, 1
%266 = getelementptr inbounds i32, i32* %1, i64 %261
store i32 %264, i32* %266
%267 = add nsw i64 %260, 2
%268 = getelementptr inbounds i32, i32* %0, i64 %262
%269 = load i32, i32* %268
%270 = add nsw i64 %261, 2
%271 = getelementptr inbounds i32, i32* %1, i64 %265
store i32 %269, i32* %271
%272 = add nsw i64 %260, 3
%273 = getelementptr inbounds i32, i32* %0, i64 %267
%274 = load i32, i32* %273
%275 = add nsw i64 %261, 3
%276 = getelementptr inbounds i32, i32* %1, i64 %270
store i32 %274, i32* %276
%277 = add nsw i64 %260, 4
%278 = getelementptr inbounds i32, i32* %0, i64 %272
%279 = load i32, i32* %278
%280 = add nsw i64 %261, 4
%281 = getelementptr inbounds i32, i32* %1, i64 %275
store i32 %279, i32* %281
%282 = icmp eq i64 %277, %22
br i1 %282, label %147, label %259
283: ; preds = %255, %409, %233, %150
%284 = icmp slt i32 %4, %2
br i1 %284, label %454, label %285
285: ; preds = %283
%286 = sext i32 %2 to i64
%287 = add i32 %4, 1
%288 = sub i32 %4, %2
%289 = zext i32 %288 to i64
%290 = add nuw nsw i64 %289, 1
%291 = icmp ult i32 %288, 7
br i1 %291, label %389, label %292
292: ; preds = %285
%293 = getelementptr i32, i32* %0, i64 %286
%294 = sub i32 %4, %2
%295 = zext i32 %294 to i64
%296 = add nsw i64 %286, %295
%297 = add nsw i64 %296, 1
%298 = getelementptr i32, i32* %0, i64 %297
%299 = getelementptr i32, i32* %1, i64 %286
%300 = getelementptr i32, i32* %1, i64 %297
%301 = icmp ult i32* %293, %300
%302 = icmp ult i32* %299, %298
%303 = and i1 %301, %302
br i1 %303, label %389, label %304
304: ; preds = %292
%305 = and i64 %290, 8589934584
%306 = add nsw i64 %305, %286
%307 = add nsw i64 %305, -8
%308 = lshr exact i64 %307, 3
%309 = add nuw nsw i64 %308, 1
%310 = and i64 %309, 3
%311 = icmp ult i64 %307, 24
br i1 %311, label %367, label %312
312: ; preds = %304
%313 = and i64 %309, 4611686018427387900
br label %314
314: ; preds = %314, %312
%315 = phi i64 [ 0, %312 ], [ %364, %314 ]
%316 = phi i64 [ 0, %312 ], [ %365, %314 ]
%317 = add i64 %315, %286
%318 = getelementptr inbounds i32, i32* %1, i64 %317
%319 = bitcast i32* %318 to <4 x i32>*
%320 = load <4 x i32>, <4 x i32>* %319
%321 = getelementptr inbounds i32, i32* %318, i64 4
%322 = bitcast i32* %321 to <4 x i32>*
%323 = load <4 x i32>, <4 x i32>* %322
%324 = getelementptr inbounds i32, i32* %0, i64 %317
%325 = bitcast i32* %324 to <4 x i32>*
store <4 x i32> %320, <4 x i32>* %325
%326 = getelementptr inbounds i32, i32* %324, i64 4
%327 = bitcast i32* %326 to <4 x i32>*
store <4 x i32> %323, <4 x i32>* %327
%328 = or i64 %315, 8
%329 = add i64 %328, %286
%330 = getelementptr inbounds i32, i32* %1, i64 %329
%331 = bitcast i32* %330 to <4 x i32>*
%332 = load <4 x i32>, <4 x i32>* %331
%333 = getelementptr inbounds i32, i32* %330, i64 4
%334 = bitcast i32* %333 to <4 x i32>*
%335 = load <4 x i32>, <4 x i32>* %334
%336 = getelementptr inbounds i32, i32* %0, i64 %329
%337 = bitcast i32* %336 to <4 x i32>*
store <4 x i32> %332, <4 x i32>* %337
%338 = getelementptr inbounds i32, i32* %336, i64 4
%339 = bitcast i32* %338 to <4 x i32>*
store <4 x i32> %335, <4 x i32>* %339
%340 = or i64 %315, 16
%341 = add i64 %340, %286
%342 = getelementptr inbounds i32, i32* %1, i64 %341
%343 = bitcast i32* %342 to <4 x i32>*
%344 = load <4 x i32>, <4 x i32>* %343
%345 = getelementptr inbounds i32, i32* %342, i64 4
%346 = bitcast i32* %345 to <4 x i32>*
%347 = load <4 x i32>, <4 x i32>* %346
%348 = getelementptr inbounds i32, i32* %0, i64 %341
%349 = bitcast i32* %348 to <4 x i32>*
store <4 x i32> %344, <4 x i32>* %349
%350 = getelementptr inbounds i32, i32* %348, i64 4
%351 = bitcast i32* %350 to <4 x i32>*
store <4 x i32> %347, <4 x i32>* %351
%352 = or i64 %315, 24
%353 = add i64 %352, %286
%354 = getelementptr inbounds i32, i32* %1, i64 %353
%355 = bitcast i32* %354 to <4 x i32>*
%356 = load <4 x i32>, <4 x i32>* %355
%357 = getelementptr inbounds i32, i32* %354, i64 4
%358 = bitcast i32* %357 to <4 x i32>*
%359 = load <4 x i32>, <4 x i32>* %358
%360 = getelementptr inbounds i32, i32* %0, i64 %353
%361 = bitcast i32* %360 to <4 x i32>*
store <4 x i32> %356, <4 x i32>* %361
%362 = getelementptr inbounds i32, i32* %360, i64 4
%363 = bitcast i32* %362 to <4 x i32>*
store <4 x i32> %359, <4 x i32>* %363
%364 = add nuw i64 %315, 32
%365 = add i64 %316, 4
%366 = icmp eq i64 %365, %313
br i1 %366, label %367, label %314
367: ; preds = %314, %304
%368 = phi i64 [ 0, %304 ], [ %364, %314 ]
%369 = icmp eq i64 %310, 0
br i1 %369, label %387, label %370
370: ; preds = %367, %370
%371 = phi i64 [ %384, %370 ], [ %368, %367 ]
%372 = phi i64 [ %385, %370 ], [ 0, %367 ]
%373 = add i64 %371, %286
%374 = getelementptr inbounds i32, i32* %1, i64 %373
%375 = bitcast i32* %374 to <4 x i32>*
%376 = load <4 x i32>, <4 x i32>* %375
%377 = getelementptr inbounds i32, i32* %374, i64 4
%378 = bitcast i32* %377 to <4 x i32>*
%379 = load <4 x i32>, <4 x i32>* %378
%380 = getelementptr inbounds i32, i32* %0, i64 %373
%381 = bitcast i32* %380 to <4 x i32>*
store <4 x i32> %376, <4 x i32>* %381
%382 = getelementptr inbounds i32, i32* %380, i64 4
%383 = bitcast i32* %382 to <4 x i32>*
store <4 x i32> %379, <4 x i32>* %383
%384 = add nuw i64 %371, 8
%385 = add i64 %372, 1
%386 = icmp eq i64 %385, %310
br i1 %386, label %387, label %370
387: ; preds = %370, %367
%388 = icmp eq i64 %290, %305
br i1 %388, label %454, label %389
389: ; preds = %292, %285, %387
%390 = phi i64 [ %286, %292 ], [ %286, %285 ], [ %306, %387 ]
%391 = add i32 %4, 1
%392 = trunc i64 %390 to i32
%393 = sub i32 %391, %392
%394 = sub i32 %4, %392
%395 = and i32 %393, 3
%396 = icmp eq i32 %395, 0
br i1 %396, label %406, label %397
397: ; preds = %389, %397
%398 = phi i64 [ %403, %397 ], [ %390, %389 ]
%399 = phi i32 [ %404, %397 ], [ 0, %389 ]
%400 = getelementptr inbounds i32, i32* %1, i64 %398
%401 = load i32, i32* %400
%402 = getelementptr inbounds i32, i32* %0, i64 %398
store i32 %401, i32* %402
%403 = add nsw i64 %398, 1
%404 = add i32 %399, 1
%405 = icmp eq i32 %404, %395
br i1 %405, label %406, label %397
406: ; preds = %397, %389
%407 = phi i64 [ %390, %389 ], [ %403, %397 ]
%408 = icmp ult i32 %394, 3
br i1 %408, label %454, label %434
409: ; preds = %255, %409
%410 = phi i64 [ %427, %409 ], [ %256, %255 ]
%411 = phi i64 [ %430, %409 ], [ %257, %255 ]
%412 = add nsw i64 %410, 1
%413 = getelementptr inbounds i32, i32* %0, i64 %410
%414 = load i32, i32* %413
%415 = add nsw i64 %411, 1
%416 = getelementptr inbounds i32, i32* %1, i64 %411
store i32 %414, i32* %416
%417 = add nsw i64 %410, 2
%418 = getelementptr inbounds i32, i32* %0, i64 %412
%419 = load i32, i32* %418
%420 = add nsw i64 %411, 2
%421 = getelementptr inbounds i32, i32* %1, i64 %415
store i32 %419, i32* %421
%422 = add nsw i64 %410, 3
%423 = getelementptr inbounds i32, i32* %0, i64 %417
%424 = load i32, i32* %423
%425 = add nsw i64 %411, 3
%426 = getelementptr inbounds i32, i32* %1, i64 %420
store i32 %424, i32* %426
%427 = add nsw i64 %410, 4
%428 = getelementptr inbounds i32, i32* %0, i64 %422
%429 = load i32, i32* %428
%430 = add nsw i64 %411, 4
%431 = getelementptr inbounds i32, i32* %1, i64 %425
store i32 %429, i32* %431
%432 = trunc i64 %427 to i32
%433 = icmp eq i32 %156, %432
br i1 %433, label %283, label %409
434: ; preds = %406, %434
%435 = phi i64 [ %451, %434 ], [ %407, %406 ]
%436 = getelementptr inbounds i32, i32* %1, i64 %435
%437 = load i32, i32* %436
%438 = getelementptr inbounds i32, i32* %0, i64 %435
store i32 %437, i32* %438
%439 = add nsw i64 %435, 1
%440 = getelementptr inbounds i32, i32* %1, i64 %439
%441 = load i32, i32* %440
%442 = getelementptr inbounds i32, i32* %0, i64 %439
store i32 %441, i32* %442
%443 = add nsw i64 %435, 2
%444 = getelementptr inbounds i32, i32* %1, i64 %443
%445 = load i32, i32* %444
%446 = getelementptr inbounds i32, i32* %0, i64 %443
store i32 %445, i32* %446
%447 = add nsw i64 %435, 3
%448 = getelementptr inbounds i32, i32* %1, i64 %447
%449 = load i32, i32* %448
%450 = getelementptr inbounds i32, i32* %0, i64 %447
store i32 %449, i32* %450
%451 = add nsw i64 %435, 4
%452 = trunc i64 %451 to i32
%453 = icmp eq i32 %287, %452
br i1 %453, label %454, label %434
454: ; preds = %406, %434, %387, %283
ret i32 %17
}