void merge(int arrayPtr[], int start, int middle, int end, int aux[]) {
  for (int i = start; i < end; ++i)
    aux[i] = arrayPtr[i];
  int idx1 = start;
  int idx2 = middle;
  int i = start;
  while (idx1 < middle && idx2 < end) {
    if (aux[idx1] < aux[idx2]) {
      arrayPtr[i] = aux[idx1];
      ++i;
      ++idx1;
    } else {
      arrayPtr[i] = aux[idx2];
      ++i;
      ++idx2;
    }
  }
  while (idx1 < middle) {
    arrayPtr[i] = aux[idx1];
    ++idx1;
    ++i;
  }
  while (idx2 < end) {
    arrayPtr[i] = aux[idx2];
    ++idx2;
    ++i;
  }
}


x86 assembly (clang, -O0):
<merge>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    114b <merge+0x4b>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    111b <merge+0x1b>
mov    -0xc(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x10(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0xc(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%ecx
xor    %eax,%eax
cmp    -0x10(%rbp),%ecx
mov    %al,-0x31(%rbp)
jge    117a <merge+0x7a>
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0x31(%rbp)
mov    -0x31(%rbp),%al
test   $0x1,%al
jne    118a <merge+0x8a>
jmp    1200 <merge+0x100>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x20(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    11d3 <merge+0xd3>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11fb <merge+0xfb>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    115d <merge+0x5d>
jmp    1205 <merge+0x105>
mov    -0x28(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    123e <merge+0x13e>
mov    -0x20(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1205 <merge+0x105>
jmp    1243 <merge+0x143>
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    127c <merge+0x17c>
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1243 <merge+0x143>
pop    %rbp
ret

x86 assembly (clang, -O2):
<merge>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
cmp    %ecx,%esi
jge    12bb <merge+0x1bb>
movslq %esi,%rax
movslq %ecx,%r9
mov    %r9,%r10
sub    %rax,%r10
cmp    $0x8,%r10
jb     1255 <merge+0x155>
lea    (%r8,%rax,4),%rbp
lea    (%rdi,%r9,4),%rbx
cmp    %rbx,%rbp
jae    1146 <merge+0x46>
lea    (%r8,%r9,4),%rbp
lea    (%rdi,%rax,4),%rbx
cmp    %rbp,%rbx
jb     1255 <merge+0x155>
mov    %r10,%r11
and    $0xfffffffffffffff8,%r11
lea    -0x8(%r11),%rbx
mov    %rbx,%r15
shr    $0x3,%r15
add    $0x1,%r15
mov    %r15d,%r14d
and    $0x3,%r14d
cmp    $0x18,%rbx
jae    1170 <merge+0x70>
xor    %ebx,%ebx
jmp    1209 <merge+0x109>
movabs $0x3ffffffffffffffe,%rbx
ff ff 3f
add    $0xfffffffffffffffe,%rbx
and    %rbx,%r15
lea    (%r8,%rax,4),%r12
add    $0x70,%r12
lea    (%rdi,%rax,4),%r13
add    $0x70,%r13
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x70(%r13,%rbx,4),%xmm0
movups -0x60(%r13,%rbx,4),%xmm1
movups %xmm0,-0x70(%r12,%rbx,4)
movups %xmm1,-0x60(%r12,%rbx,4)
movups -0x50(%r13,%rbx,4),%xmm0
movups -0x40(%r13,%rbx,4),%xmm1
movups %xmm0,-0x50(%r12,%rbx,4)
movups %xmm1,-0x40(%r12,%rbx,4)
movups -0x30(%r13,%rbx,4),%xmm0
movups -0x20(%r13,%rbx,4),%xmm1
movups %xmm0,-0x30(%r12,%rbx,4)
movups %xmm1,-0x20(%r12,%rbx,4)
movups -0x10(%r13,%rbx,4),%xmm0
movups 0x0(%r13,%rbx,4),%xmm1
movups %xmm0,-0x10(%r12,%rbx,4)
movups %xmm1,(%r12,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%r15
jne    11a0 <merge+0xa0>
test   %r14,%r14
je     124d <merge+0x14d>
add    %rax,%rbx
lea    (%r8,%rbx,4),%r15
add    $0x10,%r15
lea    (%rdi,%rbx,4),%rbx
add    $0x10,%rbx
shl    $0x5,%r14
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movups -0x10(%rbx,%rbp,1),%xmm0
movups (%rbx,%rbp,1),%xmm1
movups %xmm0,-0x10(%r15,%rbp,1)
movups %xmm1,(%r15,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r14
jne    1230 <merge+0x130>
cmp    %r11,%r10
je     12bb <merge+0x1bb>
add    %r11,%rax
mov    %ecx,%ebx
sub    %eax,%ebx
mov    %rax,%r10
not    %r10
add    %r9,%r10
and    $0x3,%rbx
je     1281 <merge+0x181>
nopl   0x0(%rax,%rax,1)
mov    (%rdi,%rax,4),%ebp
mov    %ebp,(%r8,%rax,4)
add    $0x1,%rax
add    $0xffffffffffffffff,%rbx
jne    1270 <merge+0x170>
cmp    $0x3,%r10
jb     12bb <merge+0x1bb>
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%rax,4),%ebp
mov    %ebp,(%r8,%rax,4)
mov    0x4(%rdi,%rax,4),%ebp
mov    %ebp,0x4(%r8,%rax,4)
mov    0x8(%rdi,%rax,4),%ebp
mov    %ebp,0x8(%r8,%rax,4)
mov    0xc(%rdi,%rax,4),%ebp
mov    %ebp,0xc(%r8,%rax,4)
add    $0x4,%rax
cmp    %rax,%r9
jne    1290 <merge+0x190>
cmp    %edx,%esi
jge    130b <merge+0x20b>
cmp    %ecx,%edx
jge    130b <merge+0x20b>
movslq %esi,%rax
lea    (%rdi,%rax,4),%r10
mov    %edx,%r14d
mov    %esi,%ebx
nop
movslq %ebx,%rbx
mov    (%r8,%rbx,4),%r9d
movslq %r14d,%r14
mov    (%r8,%r14,4),%ebp
xor    %r11d,%r11d
xor    %eax,%eax
cmp    %ebp,%r9d
setge  %r11b
setl   %al
cmovl  %r9d,%ebp
add    %eax,%ebx
add    %r11d,%r14d
mov    %ebp,(%r10)
add    $0x1,%esi
cmp    %edx,%ebx
jge    1310 <merge+0x210>
add    $0x4,%r10
cmp    %ecx,%r14d
jl     12d0 <merge+0x1d0>
jmp    1310 <merge+0x210>
mov    %esi,%ebx
mov    %edx,%r14d
cmp    %edx,%ebx
jge    146b <merge+0x36b>
movslq %esi,%rsi
movslq %ebx,%r10
movslq %edx,%r9
mov    %r9,%r11
sub    %r10,%r11
cmp    $0x8,%r11
jb     13f2 <merge+0x2f2>
lea    (%rdi,%rsi,4),%rax
lea    (%r8,%r9,4),%rbx
cmp    %rbx,%rax
jae    1356 <merge+0x256>
lea    (%rsi,%r9,1),%rax
sub    %r10,%rax
lea    (%rdi,%rax,4),%rax
lea    (%r8,%r10,4),%rbx
cmp    %rax,%rbx
jb     13f2 <merge+0x2f2>
mov    %r11,%r15
and    $0xfffffffffffffff8,%r15
lea    -0x8(%r15),%rax
mov    %rax,%r12
shr    $0x3,%r12
add    $0x1,%r12
test   %rax,%rax
je     15d2 <merge+0x4d2>
mov    %r12,%rax
and    $0xfffffffffffffffe,%rax
lea    (%r8,%r10,4),%r13
add    $0x30,%r13
lea    (%rdi,%rsi,4),%rbp
add    $0x30,%rbp
xor    %ebx,%ebx
xchg   %ax,%ax
movups -0x30(%r13,%rbx,4),%xmm0
movups -0x20(%r13,%rbx,4),%xmm1
movups %xmm0,-0x30(%rbp,%rbx,4)
movups %xmm1,-0x20(%rbp,%rbx,4)
movups -0x10(%r13,%rbx,4),%xmm0
movups 0x0(%r13,%rbx,4),%xmm1
movups %xmm0,-0x10(%rbp,%rbx,4)
movups %xmm1,0x0(%rbp,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rax
jne    1390 <merge+0x290>
test   $0x1,%r12b
je     13e7 <merge+0x2e7>
lea    (%rbx,%r10,1),%rax
add    %rsi,%rbx
movups (%r8,%rax,4),%xmm0
movups 0x10(%r8,%rax,4),%xmm1
movups %xmm0,(%rdi,%rbx,4)
movups %xmm1,0x10(%rdi,%rbx,4)
add    %r15,%rsi
cmp    %r15,%r11
je     146b <merge+0x36b>
add    %r15,%r10
sub    %r10d,%edx
mov    %r10,%rax
not    %rax
add    %r9,%rax
and    $0x3,%rdx
je     1425 <merge+0x325>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    (%r8,%r10,4),%ebp
mov    %ebp,(%rdi,%rsi,4)
add    $0x1,%r10
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdx
jne    1410 <merge+0x310>
cmp    $0x3,%rax
jb     146b <merge+0x36b>
sub    %r10,%r9
lea    (%r8,%r10,4),%rdx
add    $0xc,%rdx
lea    (%rdi,%rsi,4),%rbp
add    $0xc,%rbp
xor    %eax,%eax
mov    -0xc(%rdx,%rax,4),%ebx
mov    %ebx,-0xc(%rbp,%rax,4)
mov    -0x8(%rdx,%rax,4),%ebx
mov    %ebx,-0x8(%rbp,%rax,4)
mov    -0x4(%rdx,%rax,4),%ebx
mov    %ebx,-0x4(%rbp,%rax,4)
mov    (%rdx,%rax,4),%ebx
mov    %ebx,0x0(%rbp,%rax,4)
add    $0x4,%rax
cmp    %rax,%r9
jne    1440 <merge+0x340>
add    %rax,%rsi
cmp    %ecx,%r14d
jge    15c7 <merge+0x4c7>
movslq %esi,%rdx
movslq %r14d,%rsi
movslq %ecx,%r14
mov    %r14,%r9
sub    %rsi,%r9
cmp    $0x8,%r9
jb     1551 <merge+0x451>
lea    (%rdi,%rdx,4),%rax
lea    (%r8,%r14,4),%rbp
cmp    %rbp,%rax
jae    14b2 <merge+0x3b2>
lea    (%rdx,%r14,1),%rax
sub    %rsi,%rax
lea    (%rdi,%rax,4),%rax
lea    (%r8,%rsi,4),%rbp
cmp    %rax,%rbp
jb     1551 <merge+0x451>
mov    %r9,%r10
and    $0xfffffffffffffff8,%r10
lea    -0x8(%r10),%rax
mov    %rax,%r11
shr    $0x3,%r11
add    $0x1,%r11
test   %rax,%rax
je     15e3 <merge+0x4e3>
mov    %r11,%rax
and    $0xfffffffffffffffe,%rax
lea    (%r8,%rsi,4),%r15
add    $0x30,%r15
lea    (%rdi,%rdx,4),%rbp
add    $0x30,%rbp
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movups -0x30(%r15,%rbx,4),%xmm0
movups -0x20(%r15,%rbx,4),%xmm1
movups %xmm0,-0x30(%rbp,%rbx,4)
movups %xmm1,-0x20(%rbp,%rbx,4)
movups -0x10(%r15,%rbx,4),%xmm0
movups (%r15,%rbx,4),%xmm1
movups %xmm0,-0x10(%rbp,%rbx,4)
movups %xmm1,0x0(%rbp,%rbx,4)
add    $0x10,%rbx
add    $0xfffffffffffffffe,%rax
jne    14f0 <merge+0x3f0>
test   $0x1,%r11b
je     1546 <merge+0x446>
lea    (%rbx,%rsi,1),%rax
add    %rdx,%rbx
movups (%r8,%rax,4),%xmm0
movups 0x10(%r8,%rax,4),%xmm1
movups %xmm0,(%rdi,%rbx,4)
movups %xmm1,0x10(%rdi,%rbx,4)
cmp    %r10,%r9
je     15c7 <merge+0x4c7>
add    %r10,%rsi
add    %r10,%rdx
sub    %esi,%ecx
mov    %rsi,%rbx
not    %rbx
add    %r14,%rbx
and    $0x3,%rcx
je     1585 <merge+0x485>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r8,%rsi,4),%eax
mov    %eax,(%rdi,%rdx,4)
add    $0x1,%rsi
add    $0x1,%rdx
add    $0xffffffffffffffff,%rcx
jne    1570 <merge+0x470>
cmp    $0x3,%rbx
jb     15c7 <merge+0x4c7>
sub    %rsi,%r14
lea    (%r8,%rsi,4),%rax
add    $0xc,%rax
lea    (%rdi,%rdx,4),%rcx
add    $0xc,%rcx
xor    %edx,%edx
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,%r14
jne    15a0 <merge+0x4a0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %ebx,%ebx
test   $0x1,%r12b
jne    13cc <merge+0x2cc>
jmp    13e7 <merge+0x2e7>
xor    %ebx,%ebx
test   $0x1,%r11b
jne    152b <merge+0x42b>
jmp    1546 <merge+0x446>

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

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