void Copy_Pivot(int *a, int *b, int *c, int p) {
  int i;
  for (i = 0; i < p; i++)
    c[i] = a[i];
  for (i = p; i < 2 * p; i++)
    c[i] = b[i - p];
}


x86 assembly (clang, -O0):
<Copy_Pivot>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    114a <Copy_Pivot+0x4a>
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    111a <Copy_Pivot+0x1a>
mov    -0x1c(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jge    118a <Copy_Pivot+0x8a>
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
sub    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1150 <Copy_Pivot+0x50>
pop    %rbp
ret

x86 assembly (clang, -O2):
<Copy_Pivot>:
push   %r14
push   %rbx
test   %ecx,%ecx
jle    1278 <Copy_Pivot+0x178>
mov    %ecx,%r8d
cmp    $0x8,%ecx
jb     1125 <Copy_Pivot+0x25>
lea    (%rdi,%r8,4),%rax
cmp    %rdx,%rax
jbe    1194 <Copy_Pivot+0x94>
lea    (%rdx,%r8,4),%rax
cmp    %rdi,%rax
jbe    1194 <Copy_Pivot+0x94>
xor    %r14d,%r14d
mov    %r14,%r9
not    %r9
add    %r8,%r9
mov    %r8,%rbx
and    $0x3,%rbx
je     1152 <Copy_Pivot+0x52>
nopw   0x0(%rax,%rax,1)
mov    (%rdi,%r14,4),%eax
mov    %eax,(%rdx,%r14,4)
add    $0x1,%r14
add    $0xffffffffffffffff,%rbx
jne    1140 <Copy_Pivot+0x40>
cmp    $0x3,%r9
jb     1278 <Copy_Pivot+0x178>
nopl   0x0(%rax)
mov    (%rdi,%r14,4),%eax
mov    %eax,(%rdx,%r14,4)
mov    0x4(%rdi,%r14,4),%eax
mov    %eax,0x4(%rdx,%r14,4)
mov    0x8(%rdi,%r14,4),%eax
mov    %eax,0x8(%rdx,%r14,4)
mov    0xc(%rdi,%r14,4),%eax
mov    %eax,0xc(%rdx,%r14,4)
add    $0x4,%r14
cmp    %r14,%r8
jne    1160 <Copy_Pivot+0x60>
jmp    1278 <Copy_Pivot+0x178>
mov    %r8d,%r14d
and    $0xfffffff8,%r14d
lea    -0x8(%r14),%rbx
mov    %rbx,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %r10d,%r9d
and    $0x3,%r9d
cmp    $0x18,%rbx
jae    11bb <Copy_Pivot+0xbb>
xor    %ebx,%ebx
jmp    1228 <Copy_Pivot+0x128>
and    $0xfffffffffffffffc,%r10
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups (%rdi,%rbx,4),%xmm0
movups 0x10(%rdi,%rbx,4),%xmm1
movups %xmm0,(%rdx,%rbx,4)
movups %xmm1,0x10(%rdx,%rbx,4)
movups 0x20(%rdi,%rbx,4),%xmm0
movups 0x30(%rdi,%rbx,4),%xmm1
movups %xmm0,0x20(%rdx,%rbx,4)
movups %xmm1,0x30(%rdx,%rbx,4)
movups 0x40(%rdi,%rbx,4),%xmm0
movups 0x50(%rdi,%rbx,4),%xmm1
movups %xmm0,0x40(%rdx,%rbx,4)
movups %xmm1,0x50(%rdx,%rbx,4)
movups 0x60(%rdi,%rbx,4),%xmm0
movups 0x70(%rdi,%rbx,4),%xmm1
movups %xmm0,0x60(%rdx,%rbx,4)
movups %xmm1,0x70(%rdx,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%r10
jne    11d0 <Copy_Pivot+0xd0>
test   %r9,%r9
je     126f <Copy_Pivot+0x16f>
lea    (%rdx,%rbx,4),%r10
add    $0x10,%r10
lea    (%rdi,%rbx,4),%r11
add    $0x10,%r11
shl    $0x5,%r9
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%r11,%rbx,1),%xmm0
movups (%r11,%rbx,1),%xmm1
movups %xmm0,-0x10(%r10,%rbx,1)
movups %xmm1,(%r10,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r9
jne    1250 <Copy_Pivot+0x150>
cmp    %r8,%r14
jne    1128 <Copy_Pivot+0x28>
lea    (%rcx,%rcx,1),%edi
cmp    %ecx,%edi
jle    1417 <Copy_Pivot+0x317>
movslq %ecx,%r8
movslq %edi,%r11
mov    %r11,%r9
sub    %r8,%r9
mov    %r8,%rcx
cmp    $0x8,%r9
jb     1399 <Copy_Pivot+0x299>
lea    (%rdx,%r8,4),%rax
lea    (%rsi,%r9,4),%rcx
cmp    %rcx,%rax
jae    12b9 <Copy_Pivot+0x1b9>
lea    (%rdx,%r11,4),%rax
mov    %r8,%rcx
cmp    %rsi,%rax
ja     1399 <Copy_Pivot+0x299>
mov    %r9,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rax
mov    %rax,%r14
shr    $0x3,%r14
add    $0x1,%r14
mov    %r14d,%r10d
and    $0x3,%r10d
cmp    $0x18,%rax
jae    12e0 <Copy_Pivot+0x1e0>
xor    %ebx,%ebx
jmp    1348 <Copy_Pivot+0x248>
and    $0xfffffffffffffffc,%r14
lea    (%rdx,%r8,4),%rax
add    $0x70,%rax
xor    %ebx,%ebx
xchg   %ax,%ax
movups (%rsi,%rbx,4),%xmm0
movups 0x10(%rsi,%rbx,4),%xmm1
movups %xmm0,-0x70(%rax,%rbx,4)
movups %xmm1,-0x60(%rax,%rbx,4)
movups 0x20(%rsi,%rbx,4),%xmm0
movups 0x30(%rsi,%rbx,4),%xmm1
movups %xmm0,-0x50(%rax,%rbx,4)
movups %xmm1,-0x40(%rax,%rbx,4)
movups 0x40(%rsi,%rbx,4),%xmm0
movups 0x50(%rsi,%rbx,4),%xmm1
movups %xmm0,-0x30(%rax,%rbx,4)
movups %xmm1,-0x20(%rax,%rbx,4)
movups 0x60(%rsi,%rbx,4),%xmm0
movups 0x70(%rsi,%rbx,4),%xmm1
movups %xmm0,-0x10(%rax,%rbx,4)
movups %xmm1,(%rax,%rbx,4)
add    $0x20,%rbx
add    $0xfffffffffffffffc,%r14
jne    12f0 <Copy_Pivot+0x1f0>
test   %r10,%r10
je     138d <Copy_Pivot+0x28d>
lea    (%rsi,%rbx,4),%r14
add    $0x10,%r14
add    %r8,%rbx
lea    (%rdx,%rbx,4),%rbx
add    $0x10,%rbx
shl    $0x5,%r10
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
movups -0x10(%r14,%rax,1),%xmm0
movups (%r14,%rax,1),%xmm1
movups %xmm0,-0x10(%rbx,%rax,1)
movups %xmm1,(%rbx,%rax,1)
add    $0x20,%rax
cmp    %rax,%r10
jne    1370 <Copy_Pivot+0x270>
cmp    %rcx,%r9
je     1417 <Copy_Pivot+0x317>
add    %r8,%rcx
sub    %ecx,%edi
mov    %rcx,%r10
not    %r10
add    %r11,%r10
and    $0x3,%rdi
je     13d0 <Copy_Pivot+0x2d0>
lea    0x0(,%r8,4),%r9
mov    %rsi,%rbx
sub    %r9,%rbx
nopl   0x0(%rax,%rax,1)
mov    (%rbx,%rcx,4),%eax
mov    %eax,(%rdx,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    13c0 <Copy_Pivot+0x2c0>
cmp    $0x3,%r10
jb     1417 <Copy_Pivot+0x317>
mov    $0x3,%eax
sub    %r8,%rax
lea    (%rsi,%rax,4),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    -0xc(%rax,%rcx,4),%esi
mov    %esi,(%rdx,%rcx,4)
mov    -0x8(%rax,%rcx,4),%esi
mov    %esi,0x4(%rdx,%rcx,4)
mov    -0x4(%rax,%rcx,4),%esi
mov    %esi,0x8(%rdx,%rcx,4)
mov    (%rax,%rcx,4),%esi
mov    %esi,0xc(%rdx,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r11
jne    13f0 <Copy_Pivot+0x2f0>
pop    %rbx
pop    %r14
ret

LLVM IR (-O0):
define void @Copy_Pivot(i32* %0, i32* %1, i32* %2, i32 %3) {
%5 = alloca i32*
%6 = alloca i32*
%7 = alloca i32*
%8 = alloca i32
%9 = alloca i32
store i32* %0, i32** %5
store i32* %1, i32** %6
store i32* %2, i32** %7
store i32 %3, i32* %8
store i32 0, i32* %9
br label %10
10: ; preds = %24, %4
%11 = load i32, i32* %9
%12 = load i32, i32* %8
%13 = icmp slt i32 %11, %12
br i1 %13, label %14, label %27
14: ; preds = %10
%15 = load i32*, i32** %5
%16 = load i32, i32* %9
%17 = sext i32 %16 to i64
%18 = getelementptr inbounds i32, i32* %15, i64 %17
%19 = load i32, i32* %18
%20 = load i32*, i32** %7
%21 = load i32, i32* %9
%22 = sext i32 %21 to i64
%23 = getelementptr inbounds i32, i32* %20, i64 %22
store i32 %19, i32* %23
br label %24
24: ; preds = %14
%25 = load i32, i32* %9
%26 = add nsw i32 %25, 1
store i32 %26, i32* %9
br label %10
27: ; preds = %10
%28 = load i32, i32* %8
store i32 %28, i32* %9
br label %29
29: ; preds = %46, %27
%30 = load i32, i32* %9
%31 = load i32, i32* %8
%32 = mul nsw i32 2, %31
%33 = icmp slt i32 %30, %32
br i1 %33, label %34, label %49
34: ; preds = %29
%35 = load i32*, i32** %6
%36 = load i32, i32* %9
%37 = load i32, i32* %8
%38 = sub nsw i32 %36, %37
%39 = sext i32 %38 to i64
%40 = getelementptr inbounds i32, i32* %35, i64 %39
%41 = load i32, i32* %40
%42 = load i32*, i32** %7
%43 = load i32, i32* %9
%44 = sext i32 %43 to i64
%45 = getelementptr inbounds i32, i32* %42, i64 %44
store i32 %41, i32* %45
br label %46
46: ; preds = %34
%47 = load i32, i32* %9
%48 = add nsw i32 %47, 1
store i32 %48, i32* %9
br label %29
49: ; preds = %29
ret void
}

LLVM IR (-O2):
define void @Copy_Pivot(i32* nocapture %0, i32* nocapture %1, i32* nocapture writeonly %2, i32 %3) {
%5 = icmp sgt i32 %3, 0
br i1 %5, label %6, label %112
6: ; preds = %4
%7 = zext i32 %3 to i64
%8 = icmp ult i32 %3, 8
br i1 %8, label %94, label %9
9: ; preds = %6
%10 = getelementptr i32, i32* %2, i64 %7
%11 = getelementptr i32, i32* %0, i64 %7
%12 = icmp ugt i32* %11, %2
%13 = icmp ugt i32* %10, %0
%14 = and i1 %12, %13
br i1 %14, label %94, label %15
15: ; preds = %9
%16 = and i64 %7, 4294967288
%17 = add nsw i64 %16, -8
%18 = lshr exact i64 %17, 3
%19 = add nuw nsw i64 %18, 1
%20 = and i64 %19, 3
%21 = icmp ult i64 %17, 24
br i1 %21, label %73, label %22
22: ; preds = %15
%23 = and i64 %19, 4611686018427387900
br label %24
24: ; preds = %24, %22
%25 = phi i64 [ 0, %22 ], [ %70, %24 ]
%26 = phi i64 [ 0, %22 ], [ %71, %24 ]
%27 = getelementptr inbounds i32, i32* %0, i64 %25
%28 = bitcast i32* %27 to <4 x i32>*
%29 = load <4 x i32>, <4 x i32>* %28
%30 = getelementptr inbounds i32, i32* %27, i64 4
%31 = bitcast i32* %30 to <4 x i32>*
%32 = load <4 x i32>, <4 x i32>* %31
%33 = getelementptr inbounds i32, i32* %2, i64 %25
%34 = bitcast i32* %33 to <4 x i32>*
store <4 x i32> %29, <4 x i32>* %34
%35 = getelementptr inbounds i32, i32* %33, i64 4
%36 = bitcast i32* %35 to <4 x i32>*
store <4 x i32> %32, <4 x i32>* %36
%37 = or i64 %25, 8
%38 = getelementptr inbounds i32, i32* %0, i64 %37
%39 = bitcast i32* %38 to <4 x i32>*
%40 = load <4 x i32>, <4 x i32>* %39
%41 = getelementptr inbounds i32, i32* %38, i64 4
%42 = bitcast i32* %41 to <4 x i32>*
%43 = load <4 x i32>, <4 x i32>* %42
%44 = getelementptr inbounds i32, i32* %2, i64 %37
%45 = bitcast i32* %44 to <4 x i32>*
store <4 x i32> %40, <4 x i32>* %45
%46 = getelementptr inbounds i32, i32* %44, i64 4
%47 = bitcast i32* %46 to <4 x i32>*
store <4 x i32> %43, <4 x i32>* %47
%48 = or i64 %25, 16
%49 = getelementptr inbounds i32, i32* %0, i64 %48
%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* %2, 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 %25, 24
%60 = getelementptr inbounds i32, i32* %0, i64 %59
%61 = bitcast i32* %60 to <4 x i32>*
%62 = load <4 x i32>, <4 x i32>* %61
%63 = getelementptr inbounds i32, i32* %60, i64 4
%64 = bitcast i32* %63 to <4 x i32>*
%65 = load <4 x i32>, <4 x i32>* %64
%66 = getelementptr inbounds i32, i32* %2, i64 %59
%67 = bitcast i32* %66 to <4 x i32>*
store <4 x i32> %62, <4 x i32>* %67
%68 = getelementptr inbounds i32, i32* %66, i64 4
%69 = bitcast i32* %68 to <4 x i32>*
store <4 x i32> %65, <4 x i32>* %69
%70 = add nuw i64 %25, 32
%71 = add i64 %26, 4
%72 = icmp eq i64 %71, %23
br i1 %72, label %73, label %24
73: ; preds = %24, %15
%74 = phi i64 [ 0, %15 ], [ %70, %24 ]
%75 = icmp eq i64 %20, 0
br i1 %75, label %92, label %76
76: ; preds = %73, %76
%77 = phi i64 [ %89, %76 ], [ %74, %73 ]
%78 = phi i64 [ %90, %76 ], [ 0, %73 ]
%79 = getelementptr inbounds i32, i32* %0, i64 %77
%80 = bitcast i32* %79 to <4 x i32>*
%81 = load <4 x i32>, <4 x i32>* %80
%82 = getelementptr inbounds i32, i32* %79, i64 4
%83 = bitcast i32* %82 to <4 x i32>*
%84 = load <4 x i32>, <4 x i32>* %83
%85 = getelementptr inbounds i32, i32* %2, i64 %77
%86 = bitcast i32* %85 to <4 x i32>*
store <4 x i32> %81, <4 x i32>* %86
%87 = getelementptr inbounds i32, i32* %85, i64 4
%88 = bitcast i32* %87 to <4 x i32>*
store <4 x i32> %84, <4 x i32>* %88
%89 = add nuw i64 %77, 8
%90 = add i64 %78, 1
%91 = icmp eq i64 %90, %20
br i1 %91, label %92, label %76
92: ; preds = %76, %73
%93 = icmp eq i64 %16, %7
br i1 %93, label %112, label %94
94: ; preds = %9, %6, %92
%95 = phi i64 [ 0, %9 ], [ 0, %6 ], [ %16, %92 ]
%96 = xor i64 %95, -1
%97 = add nsw i64 %96, %7
%98 = and i64 %7, 3
%99 = icmp eq i64 %98, 0
br i1 %99, label %109, label %100
100: ; preds = %94, %100
%101 = phi i64 [ %106, %100 ], [ %95, %94 ]
%102 = phi i64 [ %107, %100 ], [ 0, %94 ]
%103 = getelementptr inbounds i32, i32* %0, i64 %101
%104 = load i32, i32* %103
%105 = getelementptr inbounds i32, i32* %2, i64 %101
store i32 %104, i32* %105
%106 = add nuw nsw i64 %101, 1
%107 = add i64 %102, 1
%108 = icmp eq i64 %107, %98
br i1 %108, label %109, label %100
109: ; preds = %100, %94
%110 = phi i64 [ %95, %94 ], [ %106, %100 ]
%111 = icmp ult i64 %97, 3
br i1 %111, label %112, label %233
112: ; preds = %109, %233, %92, %4
%113 = shl i32 %3, 1
%114 = icmp sgt i32 %113, %3
br i1 %114, label %115, label %275
115: ; preds = %112
%116 = sext i32 %3 to i64
%117 = sext i32 %113 to i64
%118 = sub nsw i64 %117, %116
%119 = icmp ult i64 %118, 8
br i1 %119, label %213, label %120
120: ; preds = %115
%121 = getelementptr i32, i32* %2, i64 %116
%122 = getelementptr i32, i32* %2, i64 %117
%123 = sub nsw i64 %117, %116
%124 = getelementptr i32, i32* %1, i64 %123
%125 = icmp ult i32* %121, %124
%126 = icmp ugt i32* %122, %1
%127 = and i1 %125, %126
br i1 %127, label %213, label %128
128: ; preds = %120
%129 = and i64 %118, -8
%130 = add nsw i64 %129, %116
%131 = add nsw i64 %129, -8
%132 = lshr exact i64 %131, 3
%133 = add nuw nsw i64 %132, 1
%134 = and i64 %133, 3
%135 = icmp ult i64 %131, 24
br i1 %135, label %191, label %136
136: ; preds = %128
%137 = and i64 %133, 4611686018427387900
br label %138
138: ; preds = %138, %136
%139 = phi i64 [ 0, %136 ], [ %188, %138 ]
%140 = phi i64 [ 0, %136 ], [ %189, %138 ]
%141 = add i64 %139, %116
%142 = getelementptr inbounds i32, i32* %1, i64 %139
%143 = bitcast i32* %142 to <4 x i32>*
%144 = load <4 x i32>, <4 x i32>* %143
%145 = getelementptr inbounds i32, i32* %142, i64 4
%146 = bitcast i32* %145 to <4 x i32>*
%147 = load <4 x i32>, <4 x i32>* %146
%148 = getelementptr inbounds i32, i32* %2, i64 %141
%149 = bitcast i32* %148 to <4 x i32>*
store <4 x i32> %144, <4 x i32>* %149
%150 = getelementptr inbounds i32, i32* %148, i64 4
%151 = bitcast i32* %150 to <4 x i32>*
store <4 x i32> %147, <4 x i32>* %151
%152 = or i64 %139, 8
%153 = add i64 %152, %116
%154 = getelementptr inbounds i32, i32* %1, i64 %152
%155 = bitcast i32* %154 to <4 x i32>*
%156 = load <4 x i32>, <4 x i32>* %155
%157 = getelementptr inbounds i32, i32* %154, i64 4
%158 = bitcast i32* %157 to <4 x i32>*
%159 = load <4 x i32>, <4 x i32>* %158
%160 = getelementptr inbounds i32, i32* %2, i64 %153
%161 = bitcast i32* %160 to <4 x i32>*
store <4 x i32> %156, <4 x i32>* %161
%162 = getelementptr inbounds i32, i32* %160, i64 4
%163 = bitcast i32* %162 to <4 x i32>*
store <4 x i32> %159, <4 x i32>* %163
%164 = or i64 %139, 16
%165 = add i64 %164, %116
%166 = getelementptr inbounds i32, i32* %1, i64 %164
%167 = bitcast i32* %166 to <4 x i32>*
%168 = load <4 x i32>, <4 x i32>* %167
%169 = getelementptr inbounds i32, i32* %166, i64 4
%170 = bitcast i32* %169 to <4 x i32>*
%171 = load <4 x i32>, <4 x i32>* %170
%172 = getelementptr inbounds i32, i32* %2, i64 %165
%173 = bitcast i32* %172 to <4 x i32>*
store <4 x i32> %168, <4 x i32>* %173
%174 = getelementptr inbounds i32, i32* %172, i64 4
%175 = bitcast i32* %174 to <4 x i32>*
store <4 x i32> %171, <4 x i32>* %175
%176 = or i64 %139, 24
%177 = add i64 %176, %116
%178 = getelementptr inbounds i32, i32* %1, i64 %176
%179 = bitcast i32* %178 to <4 x i32>*
%180 = load <4 x i32>, <4 x i32>* %179
%181 = getelementptr inbounds i32, i32* %178, i64 4
%182 = bitcast i32* %181 to <4 x i32>*
%183 = load <4 x i32>, <4 x i32>* %182
%184 = getelementptr inbounds i32, i32* %2, i64 %177
%185 = bitcast i32* %184 to <4 x i32>*
store <4 x i32> %180, <4 x i32>* %185
%186 = getelementptr inbounds i32, i32* %184, i64 4
%187 = bitcast i32* %186 to <4 x i32>*
store <4 x i32> %183, <4 x i32>* %187
%188 = add nuw i64 %139, 32
%189 = add i64 %140, 4
%190 = icmp eq i64 %189, %137
br i1 %190, label %191, label %138
191: ; preds = %138, %128
%192 = phi i64 [ 0, %128 ], [ %188, %138 ]
%193 = icmp eq i64 %134, 0
br i1 %193, label %211, label %194
194: ; preds = %191, %194
%195 = phi i64 [ %208, %194 ], [ %192, %191 ]
%196 = phi i64 [ %209, %194 ], [ 0, %191 ]
%197 = add i64 %195, %116
%198 = getelementptr inbounds i32, i32* %1, i64 %195
%199 = bitcast i32* %198 to <4 x i32>*
%200 = load <4 x i32>, <4 x i32>* %199
%201 = getelementptr inbounds i32, i32* %198, i64 4
%202 = bitcast i32* %201 to <4 x i32>*
%203 = load <4 x i32>, <4 x i32>* %202
%204 = getelementptr inbounds i32, i32* %2, i64 %197
%205 = bitcast i32* %204 to <4 x i32>*
store <4 x i32> %200, <4 x i32>* %205
%206 = getelementptr inbounds i32, i32* %204, i64 4
%207 = bitcast i32* %206 to <4 x i32>*
store <4 x i32> %203, <4 x i32>* %207
%208 = add nuw i64 %195, 8
%209 = add i64 %196, 1
%210 = icmp eq i64 %209, %134
br i1 %210, label %211, label %194
211: ; preds = %194, %191
%212 = icmp eq i64 %118, %129
br i1 %212, label %275, label %213
213: ; preds = %120, %115, %211
%214 = phi i64 [ %116, %120 ], [ %116, %115 ], [ %130, %211 ]
%215 = sub nsw i64 %117, %214
%216 = xor i64 %214, -1
%217 = add nsw i64 %216, %117
%218 = and i64 %215, 3
%219 = icmp eq i64 %218, 0
br i1 %219, label %230, label %220
220: ; preds = %213, %220
%221 = phi i64 [ %227, %220 ], [ %214, %213 ]
%222 = phi i64 [ %228, %220 ], [ 0, %213 ]
%223 = sub nsw i64 %221, %116
%224 = getelementptr inbounds i32, i32* %1, i64 %223
%225 = load i32, i32* %224
%226 = getelementptr inbounds i32, i32* %2, i64 %221
store i32 %225, i32* %226
%227 = add nsw i64 %221, 1
%228 = add i64 %222, 1
%229 = icmp eq i64 %228, %218
br i1 %229, label %230, label %220
230: ; preds = %220, %213
%231 = phi i64 [ %214, %213 ], [ %227, %220 ]
%232 = icmp ult i64 %217, 3
br i1 %232, label %275, label %252
233: ; preds = %109, %233
%234 = phi i64 [ %250, %233 ], [ %110, %109 ]
%235 = getelementptr inbounds i32, i32* %0, i64 %234
%236 = load i32, i32* %235
%237 = getelementptr inbounds i32, i32* %2, i64 %234
store i32 %236, i32* %237
%238 = add nuw nsw i64 %234, 1
%239 = getelementptr inbounds i32, i32* %0, i64 %238
%240 = load i32, i32* %239
%241 = getelementptr inbounds i32, i32* %2, i64 %238
store i32 %240, i32* %241
%242 = add nuw nsw i64 %234, 2
%243 = getelementptr inbounds i32, i32* %0, i64 %242
%244 = load i32, i32* %243
%245 = getelementptr inbounds i32, i32* %2, i64 %242
store i32 %244, i32* %245
%246 = add nuw nsw i64 %234, 3
%247 = getelementptr inbounds i32, i32* %0, i64 %246
%248 = load i32, i32* %247
%249 = getelementptr inbounds i32, i32* %2, i64 %246
store i32 %248, i32* %249
%250 = add nuw nsw i64 %234, 4
%251 = icmp eq i64 %250, %7
br i1 %251, label %112, label %233
252: ; preds = %230, %252
%253 = phi i64 [ %273, %252 ], [ %231, %230 ]
%254 = sub nsw i64 %253, %116
%255 = getelementptr inbounds i32, i32* %1, i64 %254
%256 = load i32, i32* %255
%257 = getelementptr inbounds i32, i32* %2, i64 %253
store i32 %256, i32* %257
%258 = add nsw i64 %253, 1
%259 = sub nsw i64 %258, %116
%260 = getelementptr inbounds i32, i32* %1, i64 %259
%261 = load i32, i32* %260
%262 = getelementptr inbounds i32, i32* %2, i64 %258
store i32 %261, i32* %262
%263 = add nsw i64 %253, 2
%264 = sub nsw i64 %263, %116
%265 = getelementptr inbounds i32, i32* %1, i64 %264
%266 = load i32, i32* %265
%267 = getelementptr inbounds i32, i32* %2, i64 %263
store i32 %266, i32* %267
%268 = add nsw i64 %253, 3
%269 = sub nsw i64 %268, %116
%270 = getelementptr inbounds i32, i32* %1, i64 %269
%271 = load i32, i32* %270
%272 = getelementptr inbounds i32, i32* %2, i64 %268
store i32 %271, i32* %272
%273 = add nsw i64 %253, 4
%274 = icmp eq i64 %273, %117
br i1 %274, label %275, label %252
275: ; preds = %230, %252, %211, %112
ret void
}