#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ omp_set_num_threads(int);
void Merge_Sort_Par(int a[], int b[], int size, int nThreads) {
  omp_set_num_threads(nThreads);
  if (size < 2)
    return;
#pragma omp parallel sections
  {
#pragma omp section
    Merge_Sort_Par(a, b, size / 2, nThreads / 2);
#pragma omp section
    Merge_Sort_Par(a + size / 2, b + size / 2, size - size / 2,
                   nThreads - nThreads / 2);
  }
#pragma omp taskwait
  {
    int i1 = 0;
    int i2 = size / 2;
    int it = 0, i;
    while (i1 < size / 2 && i2 < size) {
      if (a[i1] <= a[i2]) {
        b[it] = a[i1];
        i1 += 1;
      } else {
        b[it] = a[i2];
        i2 += 1;
      }
      it += 1;
    }
    while (i1 < size / 2) {
      b[it] = a[i1];
      i1++;
      it++;
    }
    while (i2 < size) {
      b[it] = a[i2];
      i2++;
      it++;
    }
    for (i = 0; i < size; i++)
      a[i] = b[i];
  }
}


x86 assembly (clang, -O0):
<Merge_Sort_Par>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    -0x18(%rbp),%edi
call   1030 <omp_set_num_threads@plt>
cmpl   $0x2,-0x14(%rbp)
jge    114d <Merge_Sort_Par+0x2d>
jmp    1364 <Merge_Sort_Par+0x244>
mov    -0x8(%rbp),%rdi
mov    -0x10(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x34(%rbp)
mov    -0x18(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    -0x34(%rbp),%edx
mov    %eax,%ecx
call   1040 <Merge_Sort_Par@plt>
mov    -0x8(%rbp),%rdi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x10(%rbp),%rsi
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cltq
shl    $0x2,%rax
add    %rax,%rsi
mov    -0x14(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x30(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x18(%rbp),%eax
mov    $0x2,%r8d
cltd
idiv   %r8d
mov    -0x2c(%rbp),%edx
sub    %eax,%ecx
call   1040 <Merge_Sort_Par@plt>
movl   $0x0,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x14(%rbp),%eax
mov    $0x2,%esi
cltd
idiv   %esi
mov    %eax,%edx
xor    %eax,%eax
cmp    %edx,%ecx
mov    %al,-0x35(%rbp)
jge    1222 <Merge_Sort_Par+0x102>
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
setl   %al
mov    %al,-0x35(%rbp)
mov    -0x35(%rbp),%al
test   $0x1,%al
jne    1232 <Merge_Sort_Par+0x112>
jmp    129f <Merge_Sort_Par+0x17f>
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     1272 <Merge_Sort_Par+0x152>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1291 <Merge_Sort_Par+0x171>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11f9 <Merge_Sort_Par+0xd9>
jmp    12a4 <Merge_Sort_Par+0x184>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x14(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x3c(%rbp),%eax
cmp    %ecx,%eax
jge    12ef <Merge_Sort_Par+0x1cf>
mov    -0x8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12a4 <Merge_Sort_Par+0x184>
jmp    12f4 <Merge_Sort_Par+0x1d4>
mov    -0x20(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    132d <Merge_Sort_Par+0x20d>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12f4 <Merge_Sort_Par+0x1d4>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1364 <Merge_Sort_Par+0x244>
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1334 <Merge_Sort_Par+0x214>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Merge_Sort_Par>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %ecx,%ebx
mov    %edx,%ebp
mov    %rsi,%r14
mov    %rdi,%r15
mov    %ecx,%edi
call   1030 <omp_set_num_threads@plt>
cmp    $0x2,%ebp
jl     1624 <Merge_Sort_Par+0x504>
mov    %ebp,%r12d
shr    %r12d
mov    %ebx,%r13d
shr    $0x1f,%r13d
add    %ebx,%r13d
sar    %r13d
mov    %r15,%rdi
mov    %r14,%rsi
mov    %r12d,%edx
mov    %r13d,%ecx
call   1040 <Merge_Sort_Par@plt>
lea    (%r15,%r12,4),%rdi
lea    (%r14,%r12,4),%rsi
mov    %ebp,%edx
sub    %r12d,%edx
sub    %r13d,%ebx
mov    %ebp,%r13d
mov    %ebx,%ecx
call   1040 <Merge_Sort_Par@plt>
xor    %edi,%edi
mov    %r12d,%eax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
mov    %edx,%ecx
mov    %eax,%esi
mov    %edx,%eax
mov    (%r15,%rax,4),%ebx
mov    %esi,%eax
mov    (%r15,%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    11c5 <Merge_Sort_Par+0xa5>
cmp    %r13d,%eax
jl     1190 <Merge_Sort_Par+0x70>
cmp    %r12d,%edx
jae    133d <Merge_Sort_Par+0x21d>
mov    %edi,%ecx
mov    %edx,%esi
mov    %r12d,%r11d
mov    %r11,%r10
sub    %rsi,%r10
cmp    $0x8,%r10
jb     12b6 <Merge_Sort_Par+0x196>
lea    (%r14,%rcx,4),%rdx
lea    (%r15,%r11,4),%rbp
cmp    %rbp,%rdx
jae    120a <Merge_Sort_Par+0xea>
lea    (%rcx,%r11,1),%rdx
sub    %rsi,%rdx
lea    (%r14,%rdx,4),%rdx
lea    (%r15,%rsi,4),%rbp
cmp    %rdx,%rbp
jb     12b6 <Merge_Sort_Par+0x196>
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_Par+0x513>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%r15,%rsi,4),%r12
add    $0x30,%r12
mov    %edi,%edx
lea    (%r14,%rdx,4),%rdx
add    $0x30,%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
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    1250 <Merge_Sort_Par+0x130>
test   $0x1,%r9b
je     12a7 <Merge_Sort_Par+0x187>
lea    (%rcx,%rdi,1),%rdx
add    %rsi,%rdi
movups (%r15,%rdi,4),%xmm0
movups 0x10(%r15,%rdi,4),%xmm1
movups %xmm0,(%r14,%rdx,4)
movups %xmm1,0x10(%r14,%rdx,4)
add    %r8,%rcx
cmp    %r8,%r10
je     133a <Merge_Sort_Par+0x21a>
add    %r8,%rsi
mov    %r11d,%edi
sub    %esi,%edi
mov    %rsi,%rbp
not    %rbp
add    %r11,%rbp
and    $0x3,%rdi
je     12e6 <Merge_Sort_Par+0x1c6>
nopw   0x0(%rax,%rax,1)
mov    (%r15,%rsi,4),%edx
mov    %edx,(%r14,%rcx,4)
add    $0x1,%rsi
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    12d0 <Merge_Sort_Par+0x1b0>
mov    %rcx,%rdi
cmp    $0x3,%rbp
jb     133d <Merge_Sort_Par+0x21d>
sub    %rsi,%r11
lea    (%r15,%rsi,4),%rsi
add    $0xc,%rsi
lea    (%r14,%rcx,4),%rdi
add    $0xc,%rdi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
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    1310 <Merge_Sort_Par+0x1f0>
add    %rdx,%rcx
mov    %rcx,%rdi
cmp    %r13d,%eax
jge    14a7 <Merge_Sort_Par+0x387>
mov    %edi,%ecx
mov    %eax,%edx
movslq %r13d,%r11
mov    %r11,%r10
sub    %rdx,%r10
cmp    $0x8,%r10
jb     1422 <Merge_Sort_Par+0x302>
lea    (%r14,%rcx,4),%rax
lea    (%r15,%r11,4),%rsi
cmp    %rsi,%rax
jae    1382 <Merge_Sort_Par+0x262>
lea    (%rcx,%r11,1),%rax
sub    %rdx,%rax
lea    (%r14,%rax,4),%rax
lea    (%r15,%rdx,4),%rsi
cmp    %rax,%rsi
jb     1422 <Merge_Sort_Par+0x302>
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_Par+0x524>
mov    %r9,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%r15,%rdx,4),%rsi
add    $0x30,%rsi
lea    (%r14,%rcx,4),%rax
add    $0x30,%rax
xor    %edi,%edi
nopw   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    13c0 <Merge_Sort_Par+0x2a0>
test   $0x1,%r9b
je     1413 <Merge_Sort_Par+0x2f3>
lea    (%rcx,%rdi,1),%rax
add    %rdx,%rdi
movups (%r15,%rdi,4),%xmm0
movups 0x10(%r15,%rdi,4),%xmm1
movups %xmm0,(%r14,%rax,4)
movups %xmm1,0x10(%r14,%rax,4)
cmp    %r8,%r10
je     14a7 <Merge_Sort_Par+0x387>
add    %r8,%rdx
add    %r8,%rcx
mov    %r13d,%edi
sub    %edx,%edi
mov    %rdx,%rsi
not    %rsi
add    %r11,%rsi
and    $0x3,%rdi
je     1456 <Merge_Sort_Par+0x336>
cs nopw 0x0(%rax,%rax,1)
mov    (%r15,%rdx,4),%eax
mov    %eax,(%r14,%rcx,4)
add    $0x1,%rdx
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    1440 <Merge_Sort_Par+0x320>
cmp    $0x3,%rsi
jb     14a7 <Merge_Sort_Par+0x387>
sub    %rdx,%r11
lea    (%r15,%rdx,4),%rax
add    $0xc,%rax
lea    (%r14,%rcx,4),%rcx
add    $0xc,%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
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    1480 <Merge_Sort_Par+0x360>
test   %r13d,%r13d
jle    1624 <Merge_Sort_Par+0x504>
mov    %r13d,%eax
cmp    $0x8,%r13d
jb     14cb <Merge_Sort_Par+0x3ab>
lea    (%r14,%rax,4),%rcx
cmp    %r15,%rcx
jbe    1534 <Merge_Sort_Par+0x414>
lea    (%r15,%rax,4),%rcx
cmp    %r14,%rcx
jbe    1534 <Merge_Sort_Par+0x414>
xor    %ecx,%ecx
mov    %rcx,%rdx
not    %rdx
add    %rax,%rdx
mov    %rax,%rsi
and    $0x3,%rsi
je     14f2 <Merge_Sort_Par+0x3d2>
nop
mov    (%r14,%rcx,4),%edi
mov    %edi,(%r15,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    14e0 <Merge_Sort_Par+0x3c0>
cmp    $0x3,%rdx
jb     1624 <Merge_Sort_Par+0x504>
nopl   0x0(%rax)
mov    (%r14,%rcx,4),%edx
mov    %edx,(%r15,%rcx,4)
mov    0x4(%r14,%rcx,4),%edx
mov    %edx,0x4(%r15,%rcx,4)
mov    0x8(%r14,%rcx,4),%edx
mov    %edx,0x8(%r15,%rcx,4)
mov    0xc(%r14,%rcx,4),%edx
mov    %edx,0xc(%r15,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rax
jne    1500 <Merge_Sort_Par+0x3e0>
jmp    1624 <Merge_Sort_Par+0x504>
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    155a <Merge_Sort_Par+0x43a>
xor    %edi,%edi
jmp    15d8 <Merge_Sort_Par+0x4b8>
movabs $0x3ffffffffffffffe,%rdi
ff ff 3f
add    $0xfffffffffffffffe,%rdi
and    %rdi,%rsi
xor    %edi,%edi
nopl   (%rax)
movups (%r14,%rdi,4),%xmm0
movups 0x10(%r14,%rdi,4),%xmm1
movups %xmm0,(%r15,%rdi,4)
movups %xmm1,0x10(%r15,%rdi,4)
movups 0x20(%r14,%rdi,4),%xmm0
movups 0x30(%r14,%rdi,4),%xmm1
movups %xmm0,0x20(%r15,%rdi,4)
movups %xmm1,0x30(%r15,%rdi,4)
movups 0x40(%r14,%rdi,4),%xmm0
movups 0x50(%r14,%rdi,4),%xmm1
movups %xmm0,0x40(%r15,%rdi,4)
movups %xmm1,0x50(%r15,%rdi,4)
movups 0x60(%r14,%rdi,4),%xmm0
movups 0x70(%r14,%rdi,4),%xmm1
movups %xmm0,0x60(%r15,%rdi,4)
movups %xmm1,0x70(%r15,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1570 <Merge_Sort_Par+0x450>
test   %rdx,%rdx
je     161b <Merge_Sort_Par+0x4fb>
lea    (%r15,%rdi,4),%rsi
add    $0x10,%rsi
lea    (%r14,%rdi,4),%rdi
add    $0x10,%rdi
shl    $0x5,%rdx
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
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_Par+0x4e0>
cmp    %rax,%rcx
jne    14cd <Merge_Sort_Par+0x3ad>
add    $0x8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %edi,%edi
test   $0x1,%r9b
jne    128a <Merge_Sort_Par+0x16a>
jmp    12a7 <Merge_Sort_Par+0x187>
xor    %edi,%edi
test   $0x1,%r9b
jne    13f6 <Merge_Sort_Par+0x2d6>
jmp    1413 <Merge_Sort_Par+0x2f3>

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

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