void arr_lrotate(int *arr, int n, int d) {
  int temp[d], i;
  for (i = 0; i < d; i++)
    temp[i] = arr[i];
  for (i = 0; i < n - d; i++)
    arr[i] = arr[i + n - d - 1];
  for (i = 0; i < d; i++)
    arr[i + n - d] = temp[i];
}


x86 assembly (clang, -O0):
<arr_lrotate>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    -0x10(%rbp),%eax
mov    %rsp,%rcx
mov    %rcx,-0x18(%rbp)
lea    0xf(,%rax,4),%rdx
and    $0xfffffffffffffff0,%rdx
mov    %rsp,%rcx
sub    %rdx,%rcx
mov    %rcx,-0x30(%rbp)
mov    %rcx,%rsp
mov    %rax,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1170 <arr_lrotate+0x70>
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
movslq -0x24(%rbp),%rdx
mov    (%rcx,%rdx,4),%edx
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1140 <arr_lrotate+0x40>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    -0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    11b7 <arr_lrotate+0xb7>
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0xc(%rbp),%ecx
sub    -0x10(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1177 <arr_lrotate+0x77>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    11f6 <arr_lrotate+0xf6>
mov    -0x30(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    -0xc(%rbp),%ecx
sub    -0x10(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11be <arr_lrotate+0xbe>
mov    -0x18(%rbp),%rax
mov    %rax,%rsp
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<arr_lrotate>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
push   %rax
mov    %edx,%r12d
mov    %esi,%r14d
mov    %rdi,%rbx
mov    %edx,%r13d
mov    %rsp,%r15
lea    0xf(,%r13,4),%rax
and    $0xfffffffffffffff0,%rax
sub    %rax,%r15
mov    %r15,%rsp
test   %edx,%edx
jle    1156 <arr_lrotate+0x46>
lea    0x0(,%r13,4),%rdx
mov    %r15,%rdi
mov    %rbx,%rsi
call   1030 <memcpy@plt>
mov    %r14d,%r9d
sub    %r12d,%r9d
test   %r9d,%r9d
jle    11eb <arr_lrotate+0xdb>
mov    %r12d,%r11d
not    %r11d
add    %r14d,%r11d
mov    %r9d,%r10d
cmp    $0x8,%r9d
jae    1296 <arr_lrotate+0x186>
xor    %esi,%esi
mov    %rsi,%rax
not    %rax
add    %r10,%rax
mov    %r10,%rdx
and    $0x3,%rdx
je     11a7 <arr_lrotate+0x97>
nop
lea    (%r11,%rsi,1),%ecx
movslq %ecx,%rcx
mov    (%rbx,%rcx,4),%ecx
mov    %ecx,(%rbx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rdx
jne    1190 <arr_lrotate+0x80>
cmp    $0x3,%rax
jb     11eb <arr_lrotate+0xdb>
nopl   (%rax)
lea    (%r11,%rsi,1),%eax
cltq
mov    (%rbx,%rax,4),%eax
mov    %eax,(%rbx,%rsi,4)
lea    (%r10,%rsi,1),%rax
cltq
mov    (%rbx,%rax,4),%ecx
mov    %ecx,0x4(%rbx,%rsi,4)
lea    0x1(%rax),%ecx
movslq %ecx,%rcx
mov    (%rbx,%rcx,4),%ecx
mov    %ecx,0x8(%rbx,%rsi,4)
add    $0x2,%eax
cltq
mov    (%rbx,%rax,4),%eax
mov    %eax,0xc(%rbx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%r10
jne    11b0 <arr_lrotate+0xa0>
test   %r12d,%r12d
jle    1428 <arr_lrotate+0x318>
cmp    $0x8,%r12d
jae    1377 <arr_lrotate+0x267>
xor    %ecx,%ecx
mov    %rcx,%r8
not    %r8
add    %r13,%r8
mov    %r13,%rdx
and    $0x3,%rdx
je     1236 <arr_lrotate+0x126>
mov    %r9d,%esi
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%r15,%rcx,4),%edi
lea    (%rsi,%rcx,1),%eax
cltq
mov    %edi,(%rbx,%rax,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdx
jne    1220 <arr_lrotate+0x110>
cmp    $0x3,%r8
jb     1428 <arr_lrotate+0x318>
sub    %r12d,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    (%r15,%rcx,4),%eax
lea    (%r14,%rcx,1),%rdx
movslq %edx,%rdx
mov    %eax,(%rbx,%rdx,4)
mov    0x4(%r15,%rcx,4),%eax
lea    0x1(%rdx),%esi
movslq %esi,%rsi
mov    %eax,(%rbx,%rsi,4)
mov    0x8(%r15,%rcx,4),%eax
lea    0x2(%rdx),%esi
movslq %esi,%rsi
mov    %eax,(%rbx,%rsi,4)
mov    0xc(%r15,%rcx,4),%eax
add    $0x3,%edx
movslq %edx,%rdx
mov    %eax,(%rbx,%rdx,4)
add    $0x4,%rcx
cmp    %rcx,%r13
jne    1250 <arr_lrotate+0x140>
jmp    1428 <arr_lrotate+0x318>
lea    -0x1(%r10),%rax
lea    (%r11,%rax,1),%edx
xor    %esi,%esi
cmp    %r11d,%edx
jl     117d <arr_lrotate+0x6d>
shr    $0x20,%rax
jne    117d <arr_lrotate+0x6d>
movslq %r11d,%rax
lea    (%rax,%r10,1),%rdx
lea    (%rbx,%rdx,4),%rdx
cmp    %rbx,%rdx
jbe    12d4 <arr_lrotate+0x1c4>
lea    (%rbx,%r10,4),%rdx
lea    (%rbx,%rax,4),%rax
cmp    %rdx,%rax
jb     117b <arr_lrotate+0x6b>
mov    %r10d,%esi
and    $0xfffffff8,%esi
lea    -0x8(%rsi),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     1441 <arr_lrotate+0x331>
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
mov    %r14d,%edx
sub    %r12d,%edx
add    $0x7,%edx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
lea    -0x8(%rdx),%ecx
movslq %ecx,%rcx
movups (%rbx,%rcx,4),%xmm0
movups 0x10(%rbx,%rcx,4),%xmm1
movups %xmm0,(%rbx,%rdi,4)
movups %xmm1,0x10(%rbx,%rdi,4)
movslq %edx,%rdx
movups (%rbx,%rdx,4),%xmm0
movups 0x10(%rbx,%rdx,4),%xmm1
movups %xmm0,0x20(%rbx,%rdi,4)
movups %xmm1,0x30(%rbx,%rdi,4)
add    $0x10,%rdi
add    $0x10,%edx
add    $0xfffffffffffffffe,%rax
jne    1310 <arr_lrotate+0x200>
test   $0x1,%r8b
je     1369 <arr_lrotate+0x259>
lea    (%r11,%rdi,1),%eax
cltq
movups (%rbx,%rax,4),%xmm0
movups 0x10(%rbx,%rax,4),%xmm1
movups %xmm0,(%rbx,%rdi,4)
movups %xmm1,0x10(%rbx,%rdi,4)
cmp    %r10,%rsi
jne    117d <arr_lrotate+0x6d>
jmp    11eb <arr_lrotate+0xdb>
lea    -0x1(%r13),%rax
lea    (%r9,%rax,1),%edx
xor    %ecx,%ecx
cmp    %r9d,%edx
jl     1200 <arr_lrotate+0xf0>
shr    $0x20,%rax
jne    1200 <arr_lrotate+0xf0>
mov    %r13d,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     1437 <arr_lrotate+0x327>
mov    %r8,%rax
and    $0xfffffffffffffffe,%rax
xor    %esi,%esi
mov    %r9d,%edi
xchg   %ax,%ax
movaps (%r15,%rsi,4),%xmm0
movaps 0x10(%r15,%rsi,4),%xmm1
movslq %edi,%rdi
movups %xmm0,(%rbx,%rdi,4)
movups %xmm1,0x10(%rbx,%rdi,4)
movaps 0x20(%r15,%rsi,4),%xmm0
movaps 0x30(%r15,%rsi,4),%xmm1
lea    0x8(%rdi),%edx
movslq %edx,%rdx
movups %xmm0,(%rbx,%rdx,4)
movups %xmm1,0x10(%rbx,%rdx,4)
add    $0x10,%rsi
add    $0x10,%edi
add    $0xfffffffffffffffe,%rax
jne    13c0 <arr_lrotate+0x2b0>
test   $0x1,%r8b
je     141f <arr_lrotate+0x30f>
movaps (%r15,%rsi,4),%xmm0
movaps 0x10(%r15,%rsi,4),%xmm1
lea    (%r9,%rsi,1),%eax
cltq
movups %xmm0,(%rbx,%rax,4)
movups %xmm1,0x10(%rbx,%rax,4)
cmp    %r13,%rcx
jne    1200 <arr_lrotate+0xf0>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
test   $0x1,%r8b
jne    1405 <arr_lrotate+0x2f5>
jmp    141f <arr_lrotate+0x30f>
xor    %edi,%edi
test   $0x1,%r8b
jne    1351 <arr_lrotate+0x241>
jmp    1369 <arr_lrotate+0x259>

LLVM IR (-O0):
define void @arr_lrotate(i32* %0, i32 %1, i32 %2) {
%4 = alloca i32*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i8*
%8 = alloca i64
%9 = alloca i32
store i32* %0, i32** %4
store i32 %1, i32* %5
store i32 %2, i32* %6
%10 = load i32, i32* %6
%11 = zext i32 %10 to i64
%12 = call i8* @llvm.stacksave()
store i8* %12, i8** %7
%13 = alloca i32, i64 %11
store i64 %11, i64* %8
store i32 0, i32* %9
br label %14
14: ; preds = %27, %3
%15 = load i32, i32* %9
%16 = load i32, i32* %6
%17 = icmp slt i32 %15, %16
br i1 %17, label %18, label %30
18: ; preds = %14
%19 = load i32*, i32** %4
%20 = load i32, i32* %9
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds i32, i32* %19, i64 %21
%23 = load i32, i32* %22
%24 = load i32, i32* %9
%25 = sext i32 %24 to i64
%26 = getelementptr inbounds i32, i32* %13, i64 %25
store i32 %23, i32* %26
br label %27
27: ; preds = %18
%28 = load i32, i32* %9
%29 = add nsw i32 %28, 1
store i32 %29, i32* %9
br label %14
30: ; preds = %14
store i32 0, i32* %9
br label %31
31: ; preds = %52, %30
%32 = load i32, i32* %9
%33 = load i32, i32* %5
%34 = load i32, i32* %6
%35 = sub nsw i32 %33, %34
%36 = icmp slt i32 %32, %35
br i1 %36, label %37, label %55
37: ; preds = %31
%38 = load i32*, i32** %4
%39 = load i32, i32* %9
%40 = load i32, i32* %5
%41 = add nsw i32 %39, %40
%42 = load i32, i32* %6
%43 = sub nsw i32 %41, %42
%44 = sub nsw i32 %43, 1
%45 = sext i32 %44 to i64
%46 = getelementptr inbounds i32, i32* %38, i64 %45
%47 = load i32, i32* %46
%48 = load i32*, i32** %4
%49 = load i32, i32* %9
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds i32, i32* %48, i64 %50
store i32 %47, i32* %51
br label %52
52: ; preds = %37
%53 = load i32, i32* %9
%54 = add nsw i32 %53, 1
store i32 %54, i32* %9
br label %31
55: ; preds = %31
store i32 0, i32* %9
br label %56
56: ; preds = %73, %55
%57 = load i32, i32* %9
%58 = load i32, i32* %6
%59 = icmp slt i32 %57, %58
br i1 %59, label %60, label %76
60: ; preds = %56
%61 = load i32, i32* %9
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds i32, i32* %13, i64 %62
%64 = load i32, i32* %63
%65 = load i32*, i32** %4
%66 = load i32, i32* %9
%67 = load i32, i32* %5
%68 = add nsw i32 %66, %67
%69 = load i32, i32* %6
%70 = sub nsw i32 %68, %69
%71 = sext i32 %70 to i64
%72 = getelementptr inbounds i32, i32* %65, i64 %71
store i32 %64, i32* %72
br label %73
73: ; preds = %60
%74 = load i32, i32* %9
%75 = add nsw i32 %74, 1
store i32 %75, i32* %9
br label %56
76: ; preds = %56
%77 = load i8*, i8** %7
ret void
}

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