void merge_sort(int *a, int n, int *temp) {
  if (n <= 1)
    return;
  merge_sort(a, n / 2, temp);
  merge_sort(a + n / 2, n - n / 2, temp);
  int i = 0, j = n / 2, k = 0;
  while (i < n / 2 && j < n) {
    if (a[i] <= a[j])
      temp[k++] = a[i++];
    else
      temp[k++] = a[j++];
  }
  while (i < n / 2)
    temp[k++] = a[i++];
  while (j < n)
    temp[k++] = a[j++];
  for (i = 0; i < n; i++)
    a[i] = temp[i];
}


x86 assembly (clang, -O0):
<merge_sort>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
cmpl   $0x1,-0xc(%rbp)
jg     1132 <merge_sort+0x22>
jmp    1315 <merge_sort+0x205>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%esi
mov    -0x18(%rbp),%rdx
call   1030 <merge_sort@plt>
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0xc(%rbp),%esi
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
sub    %eax,%esi
mov    -0x18(%rbp),%rdx
call   1030 <merge_sort@plt>
movl   $0x0,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0xc(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x25(%rbp)
jge    11c2 <merge_sort+0xb2>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
setl   %al
mov    %al,-0x25(%rbp)
mov    -0x25(%rbp),%al
test   $0x1,%al
jne    11d2 <merge_sort+0xc2>
jmp    124c <merge_sort+0x13c>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0x20(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     121d <merge_sort+0x10d>
mov    -0x8(%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    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1247 <merge_sort+0x137>
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    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1199 <merge_sort+0x89>
jmp    1251 <merge_sort+0x141>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x2c(%rbp),%eax
cmp    %ecx,%eax
jge    129e <merge_sort+0x18e>
mov    -0x8(%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    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    1251 <merge_sort+0x141>
jmp    12a3 <merge_sort+0x193>
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12de <merge_sort+0x1ce>
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    -0x18(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x24(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    12a3 <merge_sort+0x193>
movl   $0x0,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1315 <merge_sort+0x205>
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    12e5 <merge_sort+0x1d5>
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<merge_sort>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
cmp    $0x2,%esi
jl     1624 <merge_sort+0x514>
mov    %rdx,%r14
mov    %esi,%r15d
mov    %rdi,%r13
mov    %esi,%r12d
shr    %r12d
mov    %r12d,%esi
call   1030 <merge_sort@plt>
lea    0x0(,%r12,4),%rdi
add    %r13,%rdi
mov    %r15d,%esi
sub    %r12d,%esi
mov    %r14,%rdx
call   1030 <merge_sort@plt>
xor    %edi,%edi
mov    %r12d,%eax
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
mov    %edx,%ecx
mov    %eax,%esi
mov    %edx,%eax
mov    0x0(%r13,%rax,4),%ebx
mov    %esi,%eax
mov    0x0(%r13,%rax,4),%ebp
xor    %eax,%eax
xor    %edx,%edx
cmp    %ebp,%ebx
setg   %al
setle  %dl
cmovg  %ebp,%ebx
add    %ecx,%edx
add    %esi,%eax
mov    %ebx,(%r14,%rdi,4)
add    $0x1,%rdi
cmp    %r12d,%edx
jae    1197 <merge_sort+0x87>
cmp    %r15d,%eax
jl     1160 <merge_sort+0x50>
cmp    %r12d,%edx
jae    131d <merge_sort+0x20d>
mov    %edi,%ecx
mov    %edx,%esi
mov    %r12d,%r11d
mov    %r11,%r10
sub    %rsi,%r10
cmp    $0x8,%r10
jb     1297 <merge_sort+0x187>
lea    (%r14,%rcx,4),%rdx
lea    0x0(,%r11,4),%rbp
add    %r13,%rbp
cmp    %rbp,%rdx
jae    11ea <merge_sort+0xda>
lea    (%rcx,%r11,1),%rdx
sub    %rsi,%rdx
lea    (%r14,%rdx,4),%rdx
lea    0x0(,%rsi,4),%rbp
add    %r13,%rbp
cmp    %rdx,%rbp
jb     1297 <merge_sort+0x187>
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rdx
mov    %rdx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     1633 <merge_sort+0x523>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
lea    0x30(,%rsi,4),%r12
add    %r13,%r12
mov    %edi,%edx
lea    (%r14,%rdx,4),%rdx
add    $0x30,%rdx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups -0x30(%r12,%rdi,4),%xmm0
movups -0x20(%r12,%rdi,4),%xmm1
movups %xmm0,-0x30(%rdx,%rdi,4)
movups %xmm1,-0x20(%rdx,%rdi,4)
movups -0x10(%r12,%rdi,4),%xmm0
movups (%r12,%rdi,4),%xmm1
movups %xmm0,-0x10(%rdx,%rdi,4)
movups %xmm1,(%rdx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    1230 <merge_sort+0x120>
test   $0x1,%r9b
je     1288 <merge_sort+0x178>
lea    (%rcx,%rdi,1),%rdx
add    %rsi,%rdi
movups 0x0(%r13,%rdi,4),%xmm0
movups 0x10(%r13,%rdi,4),%xmm1
movups %xmm0,(%r14,%rdx,4)
movups %xmm1,0x10(%r14,%rdx,4)
add    %r8,%rcx
cmp    %r8,%r10
je     131a <merge_sort+0x20a>
add    %r8,%rsi
mov    %r11d,%edi
sub    %esi,%edi
mov    %rsi,%rbp
not    %rbp
add    %r11,%rbp
and    $0x3,%rdi
je     12c7 <merge_sort+0x1b7>
nopl   0x0(%rax,%rax,1)
mov    0x0(%r13,%rsi,4),%edx
add    $0x1,%rsi
mov    %edx,(%r14,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    12b0 <merge_sort+0x1a0>
mov    %rcx,%rdi
cmp    $0x3,%rbp
jb     131d <merge_sort+0x20d>
sub    %rsi,%r11
lea    0xc(,%rsi,4),%rsi
add    %r13,%rsi
lea    (%r14,%rcx,4),%rdi
add    $0xc,%rdi
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
mov    -0xc(%rsi,%rdx,4),%ebp
mov    %ebp,-0xc(%rdi,%rdx,4)
mov    -0x8(%rsi,%rdx,4),%ebp
mov    %ebp,-0x8(%rdi,%rdx,4)
mov    -0x4(%rsi,%rdx,4),%ebp
mov    %ebp,-0x4(%rdi,%rdx,4)
mov    (%rsi,%rdx,4),%ebp
mov    %ebp,(%rdi,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r11
jne    12f0 <merge_sort+0x1e0>
add    %rdx,%rcx
mov    %rcx,%rdi
cmp    %r15d,%eax
jge    1497 <merge_sort+0x387>
mov    %edi,%ecx
mov    %eax,%edx
movslq %r15d,%r11
mov    %r11,%r10
sub    %rdx,%r10
cmp    $0x8,%r10
jb     1413 <merge_sort+0x303>
lea    (%r14,%rcx,4),%rax
lea    0x0(,%r11,4),%rsi
add    %r13,%rsi
cmp    %rsi,%rax
jae    1370 <merge_sort+0x260>
lea    (%rcx,%r11,1),%rax
sub    %rdx,%rax
lea    (%r14,%rax,4),%rax
lea    0x0(,%rdx,4),%rsi
add    %r13,%rsi
cmp    %rax,%rsi
jb     1413 <merge_sort+0x303>
mov    %r10,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rax
mov    %rax,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rax,%rax
je     1644 <merge_sort+0x534>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
lea    0x30(,%rdx,4),%rsi
add    %r13,%rsi
lea    (%r14,%rcx,4),%rax
add    $0x30,%rax
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups -0x30(%rsi,%rdi,4),%xmm0
movups -0x20(%rsi,%rdi,4),%xmm1
movups %xmm0,-0x30(%rax,%rdi,4)
movups %xmm1,-0x20(%rax,%rdi,4)
movups -0x10(%rsi,%rdi,4),%xmm0
movups (%rsi,%rdi,4),%xmm1
movups %xmm0,-0x10(%rax,%rdi,4)
movups %xmm1,(%rax,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    13b0 <merge_sort+0x2a0>
test   $0x1,%r9b
je     1404 <merge_sort+0x2f4>
lea    (%rcx,%rdi,1),%rax
add    %rdx,%rdi
movups 0x0(%r13,%rdi,4),%xmm0
movups 0x10(%r13,%rdi,4),%xmm1
movups %xmm0,(%r14,%rax,4)
movups %xmm1,0x10(%r14,%rax,4)
cmp    %r8,%r10
je     1497 <merge_sort+0x387>
add    %r8,%rdx
add    %r8,%rcx
mov    %r15d,%edi
sub    %edx,%edi
mov    %rdx,%rsi
not    %rsi
add    %r11,%rsi
and    $0x3,%rdi
je     1447 <merge_sort+0x337>
nopw   0x0(%rax,%rax,1)
mov    0x0(%r13,%rdx,4),%eax
add    $0x1,%rdx
mov    %eax,(%r14,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    1430 <merge_sort+0x320>
cmp    $0x3,%rsi
jb     1497 <merge_sort+0x387>
sub    %rdx,%r11
lea    0xc(,%rdx,4),%rax
add    %r13,%rax
lea    (%r14,%rcx,4),%rcx
add    $0xc,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0xc(%rax,%rdx,4),%esi
mov    %esi,-0xc(%rcx,%rdx,4)
mov    -0x8(%rax,%rdx,4),%esi
mov    %esi,-0x8(%rcx,%rdx,4)
mov    -0x4(%rax,%rdx,4),%esi
mov    %esi,-0x4(%rcx,%rdx,4)
mov    (%rax,%rdx,4),%esi
mov    %esi,(%rcx,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r11
jne    1470 <merge_sort+0x360>
test   %r15d,%r15d
jle    1624 <merge_sort+0x514>
mov    %r15d,%eax
cmp    $0x8,%r15d
jb     14c6 <merge_sort+0x3b6>
lea    (%r14,%rax,4),%rcx
cmp    %r13,%rcx
jbe    1535 <merge_sort+0x425>
lea    0x0(,%rax,4),%rcx
add    %r13,%rcx
cmp    %r14,%rcx
jbe    1535 <merge_sort+0x425>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     14f3 <merge_sort+0x3e3>
nopw   0x0(%rax,%rax,1)
mov    (%r14,%rcx,4),%edi
mov    %edi,0x0(%r13,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    14e0 <merge_sort+0x3d0>
cmp    $0x3,%rdx
jb     1624 <merge_sort+0x514>
nopl   (%rax)
mov    (%r14,%rcx,4),%edx
mov    %edx,0x0(%r13,%rcx,4)
mov    0x4(%r14,%rcx,4),%edx
mov    %edx,0x4(%r13,%rcx,4)
mov    0x8(%r14,%rcx,4),%edx
mov    %edx,0x8(%r13,%rcx,4)
mov    0xc(%r14,%rcx,4),%edx
mov    %edx,0xc(%r13,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1500 <merge_sort+0x3f0>
jmp    1624 <merge_sort+0x514>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%edx
and    $0x3,%edx
cmp    $0x18,%rdi
jae    155b <merge_sort+0x44b>
xor    %edi,%edi
jmp    15d9 <merge_sort+0x4c9>
movabs $0x3ffffffffffffffe,%rdi
ff ff 3f
add    $0xfffffffffffffffe,%rdi
and    %rdi,%rsi
xor    %edi,%edi
xchg   %ax,%ax
movups (%r14,%rdi,4),%xmm0
movups 0x10(%r14,%rdi,4),%xmm1
movups %xmm0,0x0(%r13,%rdi,4)
movups %xmm1,0x10(%r13,%rdi,4)
movups 0x20(%r14,%rdi,4),%xmm0
movups 0x30(%r14,%rdi,4),%xmm1
movups %xmm0,0x20(%r13,%rdi,4)
movups %xmm1,0x30(%r13,%rdi,4)
movups 0x40(%r14,%rdi,4),%xmm0
movups 0x50(%r14,%rdi,4),%xmm1
movups %xmm0,0x40(%r13,%rdi,4)
movups %xmm1,0x50(%r13,%rdi,4)
movups 0x60(%r14,%rdi,4),%xmm0
movups 0x70(%r14,%rdi,4),%xmm1
movups %xmm0,0x60(%r13,%rdi,4)
movups %xmm1,0x70(%r13,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1570 <merge_sort+0x460>
test   %rdx,%rdx
je     161b <merge_sort+0x50b>
lea    0x10(,%rdi,4),%rsi
add    %r13,%rsi
lea    (%r14,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x10(%rdi,%rbp,1),%xmm0
movups (%rdi,%rbp,1),%xmm1
movups %xmm0,-0x10(%rsi,%rbp,1)
movups %xmm1,(%rsi,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%rdx
jne    1600 <merge_sort+0x4f0>
cmp    %rax,%rcx
jne    14c8 <merge_sort+0x3b8>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edi,%edi
test   $0x1,%r9b
jne    126a <merge_sort+0x15a>
jmp    1288 <merge_sort+0x178>
xor    %edi,%edi
test   $0x1,%r9b
jne    13e6 <merge_sort+0x2d6>
jmp    1404 <merge_sort+0x2f4>

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

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