void merge(int arr[], int temp[], int left, int mid, int right) {
  int i, left_end, size, temp_pos;
  left_end = mid - 1;
  temp_pos = left;
  size = right - left + 1;
  while ((left <= left_end) && (mid <= right)) {
    if (arr[left] <= arr[mid]) {
      temp[temp_pos] = arr[left];
      temp_pos = temp_pos + 1;
      left = left + 1;
    } else {
      temp[temp_pos] = arr[mid];
      temp_pos = temp_pos + 1;
      mid = mid + 1;
    }
  }
  while (left <= left_end) {
    temp[temp_pos] = arr[left];
    left = left + 1;
    temp_pos = temp_pos + 1;
  }
  while (mid <= right) {
    temp[temp_pos] = arr[mid];
    mid = mid + 1;
    temp_pos = temp_pos + 1;
  }
  for (i = 0; i <= size; ++i) {
    arr[right] = temp[right];
    right = right - 1;
  }
}


x86 assembly (clang, -O0):
<merge>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
mov    %r8d,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x24(%rbp)
mov    -0x14(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
sub    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
mov    -0x14(%rbp),%ecx
xor    %eax,%eax
cmp    -0x24(%rbp),%ecx
mov    %al,-0x2d(%rbp)
jg     114e <merge+0x4e>
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
setle  %al
mov    %al,-0x2d(%rbp)
mov    -0x2d(%rbp),%al
test   $0x1,%al
jne    115e <merge+0x5e>
jmp    11d4 <merge+0xd4>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x8(%rbp),%rcx
movslq -0x18(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jg     11a7 <merge+0xa7>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11cf <merge+0xcf>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    1131 <merge+0x31>
jmp    11d9 <merge+0xd9>
mov    -0x14(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1212 <merge+0x112>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11d9 <merge+0xd9>
jmp    1217 <merge+0x117>
mov    -0x18(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1250 <merge+0x150>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1217 <merge+0x117>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     1290 <merge+0x190>
mov    -0x10(%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
sub    $0x1,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1257 <merge+0x157>
pop    %rbp
ret

x86 assembly (clang, -O2):
<merge>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %ecx,%r12d
mov    %edx,%ebx
mov    %edx,%r10d
cmp    %ecx,%edx
jge    117a <merge+0x7a>
mov    %ecx,%r12d
mov    %edx,%ebx
mov    %edx,%r10d
cmp    %r8d,%ecx
jg     117a <merge+0x7a>
movslq %edx,%rax
lea    (%rsi,%rax,4),%r9
mov    %edx,%r10d
mov    %edx,%ebx
mov    %ecx,%r12d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq %ebx,%rbx
mov    (%rdi,%rbx,4),%ebp
movslq %r12d,%r12
mov    (%rdi,%r12,4),%r11d
xor    %r14d,%r14d
xor    %eax,%eax
cmp    %r11d,%ebp
setle  %r14b
setg   %al
cmovg  %r11d,%ebp
add    %eax,%r12d
add    %r14d,%ebx
mov    %ebp,(%r9)
add    $0x1,%r10d
cmp    %ecx,%ebx
jge    117a <merge+0x7a>
add    $0x4,%r9
cmp    %r8d,%r12d
jle    1140 <merge+0x40>
mov    %r8d,%r9d
sub    %edx,%r9d
cmp    %ecx,%ebx
jge    12ea <merge+0x1ea>
movslq %r10d,%r10
movslq %ebx,%rbx
movslq %ecx,%r11
mov    %r11,%r14
sub    %rbx,%r14
cmp    $0x8,%r14
jb     1279 <merge+0x179>
lea    (%rsi,%r10,4),%rax
lea    (%rdi,%r11,4),%rbp
cmp    %rbp,%rax
jae    11c6 <merge+0xc6>
lea    (%r10,%r11,1),%rax
sub    %rbx,%rax
lea    (%rsi,%rax,4),%rax
lea    (%rdi,%rbx,4),%rbp
cmp    %rax,%rbp
jb     1279 <merge+0x179>
mov    %r14,%r15
and    $0xfffffffffffffff8,%r15
lea    -0x8(%r15),%rax
mov    %rax,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
test   %rax,%rax
mov    %r15,-0x8(%rsp)
mov    %rbp,-0x10(%rsp)
je     15ea <merge+0x4ea>
and    $0xfffffffffffffffe,%rbp
lea    (%rdi,%rbx,4),%r15
add    $0x30,%r15
lea    (%rsi,%r10,4),%r13
add    $0x30,%r13
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x30(%r15,%rax,4),%xmm0
movups -0x20(%r15,%rax,4),%xmm1
movups %xmm0,-0x30(%r13,%rax,4)
movups %xmm1,-0x20(%r13,%rax,4)
movups -0x10(%r15,%rax,4),%xmm0
movups (%r15,%rax,4),%xmm1
movups %xmm0,-0x10(%r13,%rax,4)
movups %xmm1,0x0(%r13,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rbp
jne    1210 <merge+0x110>
testb  $0x1,-0x10(%rsp)
je     1269 <merge+0x169>
lea    (%rax,%rbx,1),%rbp
add    %r10,%rax
movups (%rdi,%rbp,4),%xmm0
movups 0x10(%rdi,%rbp,4),%xmm1
movups %xmm0,(%rsi,%rax,4)
movups %xmm1,0x10(%rsi,%rax,4)
mov    -0x8(%rsp),%rax
add    %rax,%r10
cmp    %rax,%r14
je     12ea <merge+0x1ea>
add    %rax,%rbx
sub    %ebx,%ecx
mov    %rbx,%rax
not    %rax
add    %r11,%rax
and    $0x3,%rcx
je     12a5 <merge+0x1a5>
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%rbx,4),%ebp
mov    %ebp,(%rsi,%r10,4)
add    $0x1,%rbx
add    $0x1,%r10
add    $0xffffffffffffffff,%rcx
jne    1290 <merge+0x190>
cmp    $0x3,%rax
jb     12ea <merge+0x1ea>
sub    %rbx,%r11
lea    (%rdi,%rbx,4),%rcx
add    $0xc,%rcx
lea    (%rsi,%r10,4),%rbx
add    $0xc,%rbx
xor    %eax,%eax
mov    -0xc(%rcx,%rax,4),%ebp
mov    %ebp,-0xc(%rbx,%rax,4)
mov    -0x8(%rcx,%rax,4),%ebp
mov    %ebp,-0x8(%rbx,%rax,4)
mov    -0x4(%rcx,%rax,4),%ebp
mov    %ebp,-0x4(%rbx,%rax,4)
mov    (%rcx,%rax,4),%ebp
mov    %ebp,(%rbx,%rax,4)
add    $0x4,%rax
cmp    %rax,%r11
jne    12c0 <merge+0x1c0>
add    %rax,%r10
add    $0x1,%r9d
cmp    %r8d,%r12d
jg     1468 <merge+0x368>
movslq %r10d,%rcx
movslq %r12d,%rbx
mov    %r8d,%r10d
sub    %r12d,%r10d
cmp    $0x7,%r10d
jb     13e6 <merge+0x2e6>
lea    (%rsi,%rcx,4),%rax
lea    (%rbx,%r10,1),%rbp
lea    (%rdi,%rbp,4),%rbp
add    $0x4,%rbp
cmp    %rbp,%rax
jae    133b <merge+0x23b>
lea    (%rcx,%r10,1),%rax
lea    (%rsi,%rax,4),%rax
add    $0x4,%rax
lea    (%rdi,%rbx,4),%rbp
cmp    %rax,%rbp
jb     13e6 <merge+0x2e6>
add    $0x1,%r10
mov    %r10,%r11
and    $0xfffffffffffffff8,%r11
lea    -0x8(%r11),%rax
mov    %rax,%r14
shr    $0x3,%r14
add    $0x1,%r14
test   %rax,%rax
je     15fc <merge+0x4fc>
mov    %r14,%rbp
and    $0xfffffffffffffffe,%rbp
lea    (%rdi,%rbx,4),%r15
add    $0x30,%r15
lea    (%rsi,%rcx,4),%r12
add    $0x30,%r12
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movups -0x30(%r15,%rax,4),%xmm0
movups -0x20(%r15,%rax,4),%xmm1
movups %xmm0,-0x30(%r12,%rax,4)
movups %xmm1,-0x20(%r12,%rax,4)
movups -0x10(%r15,%rax,4),%xmm0
movups (%r15,%rax,4),%xmm1
movups %xmm0,-0x10(%r12,%rax,4)
movups %xmm1,(%r12,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rbp
jne    1380 <merge+0x280>
test   $0x1,%r14b
je     13d7 <merge+0x2d7>
lea    (%rax,%rbx,1),%rbp
add    %rcx,%rax
movups (%rdi,%rbp,4),%xmm0
movups 0x10(%rdi,%rbp,4),%xmm1
movups %xmm0,(%rsi,%rax,4)
movups %xmm1,0x10(%rsi,%rax,4)
cmp    %r11,%r10
je     1468 <merge+0x368>
add    %r11,%rbx
add    %r11,%rcx
mov    %r8d,%r10d
sub    %ebx,%r10d
lea    0x1(%r10),%ebp
and    $0x3,%ebp
je     1413 <merge+0x313>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rdi,%rbx,4),%eax
mov    %eax,(%rsi,%rcx,4)
add    $0x1,%rbx
add    $0x1,%rcx
add    $0xffffffff,%ebp
jne    1400 <merge+0x300>
cmp    $0x3,%r10d
jb     1468 <merge+0x368>
mov    %r8d,%r10d
sub    %ebx,%r10d
add    $0x1,%r10d
lea    (%rdi,%rbx,4),%rbp
add    $0xc,%rbp
lea    (%rsi,%rcx,4),%rcx
add    $0xc,%rcx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0xc(%rbp,%rbx,4),%eax
mov    %eax,-0xc(%rcx,%rbx,4)
mov    -0x8(%rbp,%rbx,4),%eax
mov    %eax,-0x8(%rcx,%rbx,4)
mov    -0x4(%rbp,%rbx,4),%eax
mov    %eax,-0x4(%rcx,%rbx,4)
mov    0x0(%rbp,%rbx,4),%eax
mov    %eax,(%rcx,%rbx,4)
add    $0x4,%rbx
cmp    %ebx,%r10d
jne    1440 <merge+0x340>
test   %r9d,%r9d
js     15df <merge+0x4df>
movslq %r8d,%r10
xor    %r14d,%r14d
cmp    $0x7,%r9d
jb     15b6 <merge+0x4b6>
mov    %r9d,%r9d
mov    %r10,%rax
sub    %r9,%rax
lea    (%rdi,%rax,4),%rcx
lea    (%rsi,%r10,4),%rbp
add    $0x4,%rbp
cmp    %rbp,%rcx
jae    14b0 <merge+0x3b0>
lea    (%rdi,%r10,4),%rcx
add    $0x4,%rcx
lea    (%rsi,%rax,4),%rax
cmp    %rcx,%rax
jb     15b6 <merge+0x4b6>
add    $0x1,%r9
mov    %r9,%r14
and    $0xfffffffffffffff8,%r14
lea    -0x8(%r14),%rax
mov    %rax,%r15
shr    $0x3,%r15
add    $0x1,%r15
mov    %r15d,%r11d
and    $0x3,%r11d
cmp    $0x18,%rax
jae    14e7 <merge+0x3e7>
xor    %ecx,%ecx
test   %r11,%r11
jne    1570 <merge+0x470>
jmp    15ae <merge+0x4ae>
movabs $0x3ffffffffffffffe,%rax
ff ff 3f
add    $0xfffffffffffffffe,%rax
and    %rax,%r15
lea    (%rdi,%r10,4),%rax
add    $0xfffffffffffffff4,%rax
lea    (%rsi,%r10,4),%rbx
add    $0xfffffffffffffff4,%rbx
xor    %ecx,%ecx
nopw   0x0(%rax,%rax,1)
movups -0x10(%rbx,%rcx,4),%xmm0
movups (%rbx,%rcx,4),%xmm1
movups %xmm1,(%rax,%rcx,4)
movups %xmm0,-0x10(%rax,%rcx,4)
movups -0x30(%rbx,%rcx,4),%xmm0
movups -0x20(%rbx,%rcx,4),%xmm1
movups %xmm1,-0x20(%rax,%rcx,4)
movups %xmm0,-0x30(%rax,%rcx,4)
movups -0x50(%rbx,%rcx,4),%xmm0
movups -0x40(%rbx,%rcx,4),%xmm1
movups %xmm1,-0x40(%rax,%rcx,4)
movups %xmm0,-0x50(%rax,%rcx,4)
movups -0x70(%rbx,%rcx,4),%xmm0
movups -0x60(%rbx,%rcx,4),%xmm1
movups %xmm1,-0x60(%rax,%rcx,4)
movups %xmm0,-0x70(%rax,%rcx,4)
add    $0xffffffffffffffe0,%rcx
add    $0xfffffffffffffffc,%r15
jne    1510 <merge+0x410>
neg    %rcx
test   %r11,%r11
je     15ae <merge+0x4ae>
mov    %r10,%rbx
sub    %rcx,%rbx
lea    (%rdi,%rbx,4),%rax
add    $0xfffffffffffffff4,%rax
lea    (%rsi,%rbx,4),%rcx
add    $0xfffffffffffffff4,%rcx
shl    $0x5,%r11
xor    %ebx,%ebx
nopl   0x0(%rax)
movups -0x10(%rcx,%rbx,1),%xmm0
movups (%rcx,%rbx,1),%xmm1
movups %xmm1,(%rax,%rbx,1)
movups %xmm0,-0x10(%rax,%rbx,1)
add    $0xffffffffffffffe0,%rbx
mov    %r11,%rbp
add    %rbx,%rbp
jne    1590 <merge+0x490>
cmp    %r14,%r9
je     15df <merge+0x4df>
sub    %r14,%r10
lea    (%rsi,%r10,4),%rax
lea    (%rdi,%r10,4),%rcx
add    %edx,%r14d
sub    %r8d,%r14d
add    $0xfffffffe,%r14d
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
mov    (%rax,%rdx,4),%esi
mov    %esi,(%rcx,%rdx,4)
add    $0xffffffffffffffff,%rdx
cmp    %edx,%r14d
jne    15d0 <merge+0x4d0>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %eax,%eax
testb  $0x1,-0x10(%rsp)
jne    1250 <merge+0x150>
jmp    1269 <merge+0x169>
xor    %eax,%eax
test   $0x1,%r14b
jne    13be <merge+0x2be>
jmp    13d7 <merge+0x2d7>

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

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