void mergeSortMerge(double *array, int *sorted, int *tosort, int p, int r,
                    int q) {
  int i, j, k, first;
  i = p;
  j = r;
  for (k = p; k <= q; k++) {
    first = 0;
    if (j <= q) {
      if (i < r) {
        if (array[tosort[i]] < array[tosort[j]])
          first = 1;
      }
    } else
      first = 1;
    if (first) {
      sorted[k] = tosort[i];
      i++;
    } else {
      sorted[k] = tosort[j];
      j++;
    }
  }
  for (k = p; k <= q; k++)
    tosort[k] = sorted[k];
}


x86 assembly (clang, -O0):
<mergeSortMerge>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8d,-0x20(%rbp)
mov    %r9d,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1204 <mergeSortMerge+0x104>
movl   $0x0,-0x34(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     119d <mergeSortMerge+0x9d>
mov    -0x28(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1198 <mergeSortMerge+0x98>
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x28(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x8(%rbp),%rax
mov    -0x18(%rbp),%rcx
movslq -0x2c(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    1193 <mergeSortMerge+0x93>
movl   $0x1,-0x34(%rbp)
jmp    1198 <mergeSortMerge+0x98>
jmp    11a4 <mergeSortMerge+0xa4>
movl   $0x1,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
je     11d2 <mergeSortMerge+0xd2>
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11f1 <mergeSortMerge+0xf1>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11f6 <mergeSortMerge+0xf6>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    112d <mergeSortMerge+0x2d>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     123a <mergeSortMerge+0x13a>
mov    -0x10(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    120a <mergeSortMerge+0x10a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<mergeSortMerge>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %r9d,%r11d
sub    %ecx,%r11d
jl     130f <mergeSortMerge+0x20f>
movslq %ecx,%r14
lea    (%rsi,%r14,4),%r10
add    $0x1,%r11d
xor    %ebx,%ebx
mov    %r8d,%r15d
mov    %ecx,%r12d
jmp    1147 <mergeSortMerge+0x47>
nopl   0x0(%rax)
movslq %r12d,%rax
mov    (%rdx,%rax,4),%ebp
mov    %ebp,(%r10,%rbx,4)
add    $0x1,%r12d
add    $0x1,%rbx
cmp    %ebx,%r11d
je     1180 <mergeSortMerge+0x80>
cmp    %r9d,%r15d
jg     1130 <mergeSortMerge+0x30>
cmp    %r8d,%r12d
jge    1170 <mergeSortMerge+0x70>
movslq %r12d,%rax
movslq (%rdx,%rax,4),%rbp
movslq %r15d,%rax
movslq (%rdx,%rax,4),%rax
movsd  (%rdi,%rax,8),%xmm0
ucomisd (%rdi,%rbp,8),%xmm0
ja     1136 <mergeSortMerge+0x36>
jmp    1176 <mergeSortMerge+0x76>
nopl   (%rax)
movslq %r15d,%rax
mov    (%rdx,%rax,4),%eax
mov    %eax,(%r10,%rbx,4)
add    $0x1,%r15d
jmp    113e <mergeSortMerge+0x3e>
mov    %r9d,%edi
sub    %ecx,%edi
jl     130f <mergeSortMerge+0x20f>
cmp    $0x7,%edi
jb     12a5 <mergeSortMerge+0x1a5>
lea    (%rdx,%r14,4),%rcx
lea    (%rdi,%r14,1),%rax
lea    (%rsi,%rax,4),%rbp
add    $0x4,%rbp
cmp    %rbp,%rcx
jae    11ba <mergeSortMerge+0xba>
lea    (%rdx,%rax,4),%rax
add    $0x4,%rax
cmp    %rax,%r10
jb     12a5 <mergeSortMerge+0x1a5>
add    $0x1,%rdi
mov    %rdi,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rcx
mov    %rcx,%rax
shr    $0x3,%rax
add    $0x1,%rax
mov    %eax,%r10d
and    $0x3,%r10d
cmp    $0x18,%rcx
jae    11e5 <mergeSortMerge+0xe5>
xor    %ebp,%ebp
jmp    125a <mergeSortMerge+0x15a>
and    $0xfffffffffffffffc,%rax
lea    (%rdx,%r14,4),%rbx
add    $0x70,%rbx
lea    (%rsi,%r14,4),%rcx
add    $0x70,%rcx
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movups -0x70(%rcx,%rbp,4),%xmm0
movups -0x60(%rcx,%rbp,4),%xmm1
movups %xmm0,-0x70(%rbx,%rbp,4)
movups %xmm1,-0x60(%rbx,%rbp,4)
movups -0x50(%rcx,%rbp,4),%xmm0
movups -0x40(%rcx,%rbp,4),%xmm1
movups %xmm0,-0x50(%rbx,%rbp,4)
movups %xmm1,-0x40(%rbx,%rbp,4)
movups -0x30(%rcx,%rbp,4),%xmm0
movups -0x20(%rcx,%rbp,4),%xmm1
movups %xmm0,-0x30(%rbx,%rbp,4)
movups %xmm1,-0x20(%rbx,%rbp,4)
movupd -0x10(%rcx,%rbp,4),%xmm0
movups (%rcx,%rbp,4),%xmm1
movupd %xmm0,-0x10(%rbx,%rbp,4)
movups %xmm1,(%rbx,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rax
jne    1200 <mergeSortMerge+0x100>
test   %r10,%r10
je     129d <mergeSortMerge+0x19d>
add    %r14,%rbp
lea    (%rdx,%rbp,4),%rax
add    $0x10,%rax
lea    (%rsi,%rbp,4),%rcx
add    $0x10,%rcx
shl    $0x5,%r10
xor    %ebp,%ebp
nopl   0x0(%rax,%rax,1)
movupd -0x10(%rcx,%rbp,1),%xmm0
movups (%rcx,%rbp,1),%xmm1
movupd %xmm0,-0x10(%rax,%rbp,1)
movups %xmm1,(%rax,%rbp,1)
add    $0x20,%rbp
cmp    %rbp,%r10
jne    1280 <mergeSortMerge+0x180>
cmp    %r8,%rdi
je     130f <mergeSortMerge+0x20f>
add    %r8,%r14
lea    0x1(%r9),%eax
mov    %eax,%ecx
sub    %r14d,%ecx
sub    %r14d,%r9d
and    $0x3,%ecx
je     12d1 <mergeSortMerge+0x1d1>
cs nopw 0x0(%rax,%rax,1)
mov    (%rsi,%r14,4),%edi
mov    %edi,(%rdx,%r14,4)
add    $0x1,%r14
add    $0xffffffff,%ecx
jne    12c0 <mergeSortMerge+0x1c0>
cmp    $0x3,%r9d
jb     130f <mergeSortMerge+0x20f>
mov    %eax,%eax
nopl   0x0(%rax)
mov    (%rsi,%r14,4),%ecx
mov    %ecx,(%rdx,%r14,4)
mov    0x4(%rsi,%r14,4),%ecx
mov    %ecx,0x4(%rdx,%r14,4)
mov    0x8(%rsi,%r14,4),%ecx
mov    %ecx,0x8(%rdx,%r14,4)
mov    0xc(%rsi,%r14,4),%ecx
mov    %ecx,0xc(%rdx,%r14,4)
add    $0x4,%r14
cmp    %r14d,%eax
jne    12e0 <mergeSortMerge+0x1e0>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @mergeSortMerge(double* %0, i32* %1, i32* %2, i32 %3, i32 %4, i32 %5) {
%7 = alloca double*
%8 = alloca i32*
%9 = alloca i32*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
store double* %0, double** %7
store i32* %1, i32** %8
store i32* %2, i32** %9
store i32 %3, i32* %10
store i32 %4, i32* %11
store i32 %5, i32* %12
%17 = load i32, i32* %10
store i32 %17, i32* %13
%18 = load i32, i32* %11
store i32 %18, i32* %14
%19 = load i32, i32* %10
store i32 %19, i32* %15
br label %20
20: ; preds = %84, %6
%21 = load i32, i32* %15
%22 = load i32, i32* %12
%23 = icmp sle i32 %21, %22
br i1 %23, label %24, label %87
24: ; preds = %20
store i32 0, i32* %16
%25 = load i32, i32* %14
%26 = load i32, i32* %12
%27 = icmp sle i32 %25, %26
br i1 %27, label %28, label %55
28: ; preds = %24
%29 = load i32, i32* %13
%30 = load i32, i32* %11
%31 = icmp slt i32 %29, %30
br i1 %31, label %32, label %54
32: ; preds = %28
%33 = load double*, double** %7
%34 = load i32*, i32** %9
%35 = load i32, i32* %13
%36 = sext i32 %35 to i64
%37 = getelementptr inbounds i32, i32* %34, i64 %36
%38 = load i32, i32* %37
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds double, double* %33, i64 %39
%41 = load double, double* %40
%42 = load double*, double** %7
%43 = load i32*, i32** %9
%44 = load i32, i32* %14
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i32, i32* %43, i64 %45
%47 = load i32, i32* %46
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds double, double* %42, i64 %48
%50 = load double, double* %49
%51 = fcmp olt double %41, %50
br i1 %51, label %52, label %53
52: ; preds = %32
store i32 1, i32* %16
br label %53
53: ; preds = %52, %32
br label %54
54: ; preds = %53, %28
br label %56
55: ; preds = %24
store i32 1, i32* %16
br label %56
56: ; preds = %55, %54
%57 = load i32, i32* %16
%58 = icmp ne i32 %57, 0
br i1 %58, label %59, label %71
59: ; preds = %56
%60 = load i32*, i32** %9
%61 = load i32, i32* %13
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds i32, i32* %60, i64 %62
%64 = load i32, i32* %63
%65 = load i32*, i32** %8
%66 = load i32, i32* %15
%67 = sext i32 %66 to i64
%68 = getelementptr inbounds i32, i32* %65, i64 %67
store i32 %64, i32* %68
%69 = load i32, i32* %13
%70 = add nsw i32 %69, 1
store i32 %70, i32* %13
br label %83
71: ; preds = %56
%72 = load i32*, i32** %9
%73 = load i32, i32* %14
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds i32, i32* %72, i64 %74
%76 = load i32, i32* %75
%77 = load i32*, i32** %8
%78 = load i32, i32* %15
%79 = sext i32 %78 to i64
%80 = getelementptr inbounds i32, i32* %77, i64 %79
store i32 %76, i32* %80
%81 = load i32, i32* %14
%82 = add nsw i32 %81, 1
store i32 %82, i32* %14
br label %83
83: ; preds = %71, %59
br label %84
84: ; preds = %83
%85 = load i32, i32* %15
%86 = add nsw i32 %85, 1
store i32 %86, i32* %15
br label %20
87: ; preds = %20
%88 = load i32, i32* %10
store i32 %88, i32* %15
br label %89
89: ; preds = %103, %87
%90 = load i32, i32* %15
%91 = load i32, i32* %12
%92 = icmp sle i32 %90, %91
br i1 %92, label %93, label %106
93: ; preds = %89
%94 = load i32*, i32** %8
%95 = load i32, i32* %15
%96 = sext i32 %95 to i64
%97 = getelementptr inbounds i32, i32* %94, i64 %96
%98 = load i32, i32* %97
%99 = load i32*, i32** %9
%100 = load i32, i32* %15
%101 = sext i32 %100 to i64
%102 = getelementptr inbounds i32, i32* %99, i64 %101
store i32 %98, i32* %102
br label %103
103: ; preds = %93
%104 = load i32, i32* %15
%105 = add nsw i32 %104, 1
store i32 %105, i32* %15
br label %89
106: ; preds = %89
ret void
}

LLVM IR (-O2):
define void @mergeSortMerge(double* nocapture %0, i32* nocapture %1, i32* nocapture %2, i32 %3, i32 %4, i32 %5) {
%7 = icmp slt i32 %5, %3
br i1 %7, label %199, label %8
8: ; preds = %6
%9 = sext i32 %3 to i64
%10 = add i32 %5, 1
br label %136
11: ; preds = %173
br i1 %7, label %199, label %12
12: ; preds = %11
%13 = sext i32 %3 to i64
%14 = add i32 %5, 1
%15 = sub i32 %5, %3
%16 = zext i32 %15 to i64
%17 = add nuw nsw i64 %16, 1
%18 = icmp ult i32 %15, 7
br i1 %18, label %116, label %19
19: ; preds = %12
%20 = getelementptr i32, i32* %2, i64 %9
%21 = sub i32 %5, %3
%22 = zext i32 %21 to i64
%23 = add nsw i64 %9, %22
%24 = add nsw i64 %23, 1
%25 = getelementptr i32, i32* %2, i64 %24
%26 = getelementptr i32, i32* %1, i64 %9
%27 = getelementptr i32, i32* %1, i64 %24
%28 = icmp ult i32* %20, %27
%29 = icmp ult i32* %26, %25
%30 = and i1 %28, %29
br i1 %30, label %116, label %31
31: ; preds = %19
%32 = and i64 %17, 8589934584
%33 = add nsw i64 %32, %13
%34 = add nsw i64 %32, -8
%35 = lshr exact i64 %34, 3
%36 = add nuw nsw i64 %35, 1
%37 = and i64 %36, 3
%38 = icmp ult i64 %34, 24
br i1 %38, label %94, label %39
39: ; preds = %31
%40 = and i64 %36, 4611686018427387900
br label %41
41: ; preds = %41, %39
%42 = phi i64 [ 0, %39 ], [ %91, %41 ]
%43 = phi i64 [ 0, %39 ], [ %92, %41 ]
%44 = add i64 %42, %13
%45 = getelementptr inbounds i32, i32* %1, i64 %44
%46 = bitcast i32* %45 to <4 x i32>*
%47 = load <4 x i32>, <4 x i32>* %46
%48 = getelementptr inbounds i32, i32* %45, i64 4
%49 = bitcast i32* %48 to <4 x i32>*
%50 = load <4 x i32>, <4 x i32>* %49
%51 = getelementptr inbounds i32, i32* %2, i64 %44
%52 = bitcast i32* %51 to <4 x i32>*
store <4 x i32> %47, <4 x i32>* %52
%53 = getelementptr inbounds i32, i32* %51, i64 4
%54 = bitcast i32* %53 to <4 x i32>*
store <4 x i32> %50, <4 x i32>* %54
%55 = or i64 %42, 8
%56 = add i64 %55, %13
%57 = getelementptr inbounds i32, i32* %1, i64 %56
%58 = bitcast i32* %57 to <4 x i32>*
%59 = load <4 x i32>, <4 x i32>* %58
%60 = getelementptr inbounds i32, i32* %57, i64 4
%61 = bitcast i32* %60 to <4 x i32>*
%62 = load <4 x i32>, <4 x i32>* %61
%63 = getelementptr inbounds i32, i32* %2, i64 %56
%64 = bitcast i32* %63 to <4 x i32>*
store <4 x i32> %59, <4 x i32>* %64
%65 = getelementptr inbounds i32, i32* %63, i64 4
%66 = bitcast i32* %65 to <4 x i32>*
store <4 x i32> %62, <4 x i32>* %66
%67 = or i64 %42, 16
%68 = add i64 %67, %13
%69 = getelementptr inbounds i32, i32* %1, i64 %68
%70 = bitcast i32* %69 to <4 x i32>*
%71 = load <4 x i32>, <4 x i32>* %70
%72 = getelementptr inbounds i32, i32* %69, i64 4
%73 = bitcast i32* %72 to <4 x i32>*
%74 = load <4 x i32>, <4 x i32>* %73
%75 = getelementptr inbounds i32, i32* %2, i64 %68
%76 = bitcast i32* %75 to <4 x i32>*
store <4 x i32> %71, <4 x i32>* %76
%77 = getelementptr inbounds i32, i32* %75, i64 4
%78 = bitcast i32* %77 to <4 x i32>*
store <4 x i32> %74, <4 x i32>* %78
%79 = or i64 %42, 24
%80 = add i64 %79, %13
%81 = getelementptr inbounds i32, i32* %1, i64 %80
%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* %2, 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
%91 = add nuw i64 %42, 32
%92 = add i64 %43, 4
%93 = icmp eq i64 %92, %40
br i1 %93, label %94, label %41
94: ; preds = %41, %31
%95 = phi i64 [ 0, %31 ], [ %91, %41 ]
%96 = icmp eq i64 %37, 0
br i1 %96, label %114, label %97
97: ; preds = %94, %97
%98 = phi i64 [ %111, %97 ], [ %95, %94 ]
%99 = phi i64 [ %112, %97 ], [ 0, %94 ]
%100 = add i64 %98, %13
%101 = getelementptr inbounds i32, i32* %1, i64 %100
%102 = bitcast i32* %101 to <4 x i32>*
%103 = load <4 x i32>, <4 x i32>* %102
%104 = getelementptr inbounds i32, i32* %101, i64 4
%105 = bitcast i32* %104 to <4 x i32>*
%106 = load <4 x i32>, <4 x i32>* %105
%107 = getelementptr inbounds i32, i32* %2, i64 %100
%108 = bitcast i32* %107 to <4 x i32>*
store <4 x i32> %103, <4 x i32>* %108
%109 = getelementptr inbounds i32, i32* %107, i64 4
%110 = bitcast i32* %109 to <4 x i32>*
store <4 x i32> %106, <4 x i32>* %110
%111 = add nuw i64 %98, 8
%112 = add i64 %99, 1
%113 = icmp eq i64 %112, %37
br i1 %113, label %114, label %97
114: ; preds = %97, %94
%115 = icmp eq i64 %17, %32
br i1 %115, label %199, label %116
116: ; preds = %19, %12, %114
%117 = phi i64 [ %13, %19 ], [ %13, %12 ], [ %33, %114 ]
%118 = add i32 %5, 1
%119 = trunc i64 %117 to i32
%120 = sub i32 %118, %119
%121 = sub i32 %5, %119
%122 = and i32 %120, 3
%123 = icmp eq i32 %122, 0
br i1 %123, label %133, label %124
124: ; preds = %116, %124
%125 = phi i64 [ %130, %124 ], [ %117, %116 ]
%126 = phi i32 [ %131, %124 ], [ 0, %116 ]
%127 = getelementptr inbounds i32, i32* %1, i64 %125
%128 = load i32, i32* %127
%129 = getelementptr inbounds i32, i32* %2, i64 %125
store i32 %128, i32* %129
%130 = add nsw i64 %125, 1
%131 = add i32 %126, 1
%132 = icmp eq i32 %131, %122
br i1 %132, label %133, label %124
133: ; preds = %124, %116
%134 = phi i64 [ %117, %116 ], [ %130, %124 ]
%135 = icmp ult i32 %121, 3
br i1 %135, label %199, label %179
136: ; preds = %8, %173
%137 = phi i64 [ %9, %8 ], [ %176, %173 ]
%138 = phi i32 [ %4, %8 ], [ %175, %173 ]
%139 = phi i32 [ %3, %8 ], [ %174, %173 ]
%140 = icmp sgt i32 %138, %5
br i1 %140, label %141, label %145
141: ; preds = %136
%142 = sext i32 %139 to i64
%143 = getelementptr inbounds i32, i32* %2, i64 %142
%144 = load i32, i32* %143
br label %165
145: ; preds = %136
%146 = icmp slt i32 %139, %4
br i1 %146, label %151, label %147
147: ; preds = %145
%148 = sext i32 %138 to i64
%149 = getelementptr inbounds i32, i32* %2, i64 %148
%150 = load i32, i32* %149
br label %169
151: ; preds = %145
%152 = sext i32 %139 to i64
%153 = getelementptr inbounds i32, i32* %2, i64 %152
%154 = load i32, i32* %153
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds double, double* %0, i64 %155
%157 = load double, double* %156
%158 = sext i32 %138 to i64
%159 = getelementptr inbounds i32, i32* %2, i64 %158
%160 = load i32, i32* %159
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds double, double* %0, i64 %161
%163 = load double, double* %162
%164 = fcmp olt double %157, %163
br i1 %164, label %165, label %169
165: ; preds = %141, %151
%166 = phi i32 [ %144, %141 ], [ %154, %151 ]
%167 = getelementptr inbounds i32, i32* %1, i64 %137
store i32 %166, i32* %167
%168 = add nsw i32 %139, 1
br label %173
169: ; preds = %147, %151
%170 = phi i32 [ %150, %147 ], [ %160, %151 ]
%171 = getelementptr inbounds i32, i32* %1, i64 %137
store i32 %170, i32* %171
%172 = add nsw i32 %138, 1
br label %173
173: ; preds = %165, %169
%174 = phi i32 [ %168, %165 ], [ %139, %169 ]
%175 = phi i32 [ %138, %165 ], [ %172, %169 ]
%176 = add nsw i64 %137, 1
%177 = trunc i64 %176 to i32
%178 = icmp eq i32 %10, %177
br i1 %178, label %11, label %136
179: ; preds = %133, %179
%180 = phi i64 [ %196, %179 ], [ %134, %133 ]
%181 = getelementptr inbounds i32, i32* %1, i64 %180
%182 = load i32, i32* %181
%183 = getelementptr inbounds i32, i32* %2, i64 %180
store i32 %182, i32* %183
%184 = add nsw i64 %180, 1
%185 = getelementptr inbounds i32, i32* %1, i64 %184
%186 = load i32, i32* %185
%187 = getelementptr inbounds i32, i32* %2, i64 %184
store i32 %186, i32* %187
%188 = add nsw i64 %180, 2
%189 = getelementptr inbounds i32, i32* %1, i64 %188
%190 = load i32, i32* %189
%191 = getelementptr inbounds i32, i32* %2, i64 %188
store i32 %190, i32* %191
%192 = add nsw i64 %180, 3
%193 = getelementptr inbounds i32, i32* %1, i64 %192
%194 = load i32, i32* %193
%195 = getelementptr inbounds i32, i32* %2, i64 %192
store i32 %194, i32* %195
%196 = add nsw i64 %180, 4
%197 = trunc i64 %196 to i32
%198 = icmp eq i32 %14, %197
br i1 %198, label %199, label %179
199: ; preds = %133, %179, %114, %6, %11
ret void
}