void perfect_shuffle2(int *a, int n) {
  int t, i;
  if (n == 1) {
    t = a[1];
    a[1] = a[2];
    a[2] = t;
    return;
  }
  int n2 = n * 2, n3 = n / 2;
  if (n % 2 == 1) {
    t = a[n];
    for (i = n + 1; i <= n2; ++i) {
      a[i - 1] = a[i];
    }
    a[n2] = t;
    --n;
  }
  for (i = n3 + 1; i <= n; ++i) {
    t = a[i];
    a[i] = a[i + n3];
    a[i + n3] = t;
  }
  perfect_shuffle2(a, n3);
  perfect_shuffle2(a + n, n3);
}


x86 assembly (clang, -O0):
<perfect_shuffle2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x20,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
cmpl   $0x1,-0xc(%rbp)
jne    1150 <perfect_shuffle2+0x40>
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x4(%rax)
mov    -0x10(%rbp),%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,0x8(%rax)
jmp    1260 <perfect_shuffle2+0x150>
mov    -0xc(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x18(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
cmp    $0x1,%edx
jne    11de <perfect_shuffle2+0xce>
mov    -0x8(%rbp),%rax
movslq -0xc(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x10(%rbp)
mov    -0xc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     11c7 <perfect_shuffle2+0xb7>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    1192 <perfect_shuffle2+0x82>
mov    -0x10(%rbp),%edx
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0xc(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0xc(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
cmp    -0xc(%rbp),%eax
jg     123d <perfect_shuffle2+0x12d>
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%edx
mov    -0x8(%rbp),%rax
movslq -0x14(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x10(%rbp),%edx
mov    -0x8(%rbp),%rax
mov    -0x14(%rbp),%ecx
add    -0x1c(%rbp),%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x14(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x14(%rbp)
jmp    11e7 <perfect_shuffle2+0xd7>
mov    -0x8(%rbp),%rdi
mov    -0x1c(%rbp),%esi
call   1030 <perfect_shuffle2@plt>
mov    -0x8(%rbp),%rdi
movslq -0xc(%rbp),%rax
shl    $0x2,%rax
add    %rax,%rdi
mov    -0x1c(%rbp),%esi
call   1030 <perfect_shuffle2@plt>
add    $0x20,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<perfect_shuffle2>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
mov    %rdi,%rbx
cmp    $0x1,%esi
jne    112e <perfect_shuffle2+0x1e>
rolq   $0x20,0x4(%rbx)
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %esi,%r15d
movabs $0x3ffffffffffffffe,%r14
ff ff 3f
jmp    115c <perfect_shuffle2+0x4c>
nopl   (%rax)
movslq %r11d,%rbp
mov    %rbx,%rdi
mov    %r15d,%esi
call   1030 <perfect_shuffle2@plt>
lea    (%rbx,%rbp,4),%rbx
and    $0xfffffffe,%r12d
cmp    $0x2,%r12d
je     1120 <perfect_shuffle2+0x10>
mov    %r15d,%r12d
mov    %r15d,%eax
shr    $0x1f,%eax
add    %r15d,%eax
mov    %eax,%r15d
sar    %r15d
and    $0xfffffffe,%eax
mov    %r12d,%ecx
sub    %eax,%ecx
mov    %r12d,%r11d
cmp    $0x1,%ecx
jne    125c <perfect_shuffle2+0x14c>
lea    (%r12,%r12,1),%eax
movslq %r12d,%rcx
mov    (%rbx,%rcx,4),%r9d
movslq %eax,%rdx
cmp    %eax,%r12d
jge    1253 <perfect_shuffle2+0x143>
mov    %rdx,%rsi
sub    %rcx,%rsi
cmp    $0x8,%rsi
jb     1240 <perfect_shuffle2+0x130>
mov    %rsi,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rax
mov    %rax,%r10
shr    $0x3,%r10
add    $0x1,%r10
test   %rax,%rax
je     1410 <perfect_shuffle2+0x300>
mov    %r10,%rbp
and    %r14,%rbp
lea    (%rbx,%rcx,4),%rax
add    $0x34,%rax
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups -0x30(%rax,%rdi,4),%xmm0
movups -0x20(%rax,%rdi,4),%xmm1
movups -0x10(%rax,%rdi,4),%xmm2
movups (%rax,%rdi,4),%xmm3
movups %xmm0,-0x34(%rax,%rdi,4)
movups %xmm1,-0x24(%rax,%rdi,4)
movups %xmm2,-0x14(%rax,%rdi,4)
movups %xmm3,-0x4(%rax,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbp
jne    11e0 <perfect_shuffle2+0xd0>
test   $0x1,%r10b
je     122d <perfect_shuffle2+0x11d>
add    %rcx,%rdi
movups 0x4(%rbx,%rdi,4),%xmm0
movups 0x14(%rbx,%rdi,4),%xmm1
movups %xmm0,(%rbx,%rdi,4)
movups %xmm1,0x10(%rbx,%rdi,4)
cmp    %r8,%rsi
je     1253 <perfect_shuffle2+0x143>
add    %r8,%rcx
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x4(%rbx,%rcx,4),%eax
mov    %eax,(%rbx,%rcx,4)
lea    0x1(%rcx),%rax
mov    %rax,%rcx
cmp    %rax,%rdx
jne    1240 <perfect_shuffle2+0x130>
mov    %r9d,(%rbx,%rdx,4)
lea    -0x1(%r12),%r11d
cmp    %r11d,%r15d
jge    1140 <perfect_shuffle2+0x30>
movslq %r15d,%r10
movslq %r11d,%rbp
mov    %rbp,%r9
sub    %r10,%r9
mov    %r10,%rdx
cmp    $0x8,%r9
jb     1390 <perfect_shuffle2+0x280>
lea    (%rbx,%r10,4),%rax
add    $0x4,%rax
lea    (%r10,%rbp,1),%rcx
lea    (%rbx,%rcx,4),%rcx
add    $0x4,%rcx
cmp    %rcx,%rax
jae    12b3 <perfect_shuffle2+0x1a3>
lea    (%rbx,%rbp,4),%rax
add    $0x4,%rax
lea    (%rbx,%r10,8),%rcx
add    $0x4,%rcx
mov    %r10,%rdx
cmp    %rax,%rcx
jb     1390 <perfect_shuffle2+0x280>
mov    %r9,%rdx
and    $0xfffffffffffffff8,%rdx
lea    -0x8(%rdx),%rax
mov    %rax,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rax,%rax
je     13ff <perfect_shuffle2+0x2ef>
mov    %r8,%rsi
and    %r14,%rsi
lea    (%rbx,%r10,8),%rax
add    $0x34,%rax
lea    (%rbx,%r10,4),%rcx
add    $0x34,%rcx
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups -0x30(%rcx,%rdi,4),%xmm0
movups -0x20(%rcx,%rdi,4),%xmm1
movups -0x30(%rax,%rdi,4),%xmm2
movups -0x20(%rax,%rdi,4),%xmm3
movups %xmm2,-0x30(%rcx,%rdi,4)
movups %xmm3,-0x20(%rcx,%rdi,4)
movups %xmm0,-0x30(%rax,%rdi,4)
movups %xmm1,-0x20(%rax,%rdi,4)
movups -0x10(%rcx,%rdi,4),%xmm0
movups (%rcx,%rdi,4),%xmm1
movups -0x10(%rax,%rdi,4),%xmm2
movups (%rax,%rdi,4),%xmm3
movups %xmm2,-0x10(%rcx,%rdi,4)
movups %xmm3,(%rcx,%rdi,4)
movups %xmm0,-0x10(%rax,%rdi,4)
movups %xmm1,(%rax,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    12f0 <perfect_shuffle2+0x1e0>
test   $0x1,%r8b
je     137d <perfect_shuffle2+0x26d>
add    %r10,%rdi
movups 0x4(%rbx,%rdi,4),%xmm0
movups 0x14(%rbx,%rdi,4),%xmm1
lea    (%r10,%rdi,1),%rax
add    $0x1,%rax
movups (%rbx,%rax,4),%xmm2
movups 0x10(%rbx,%rax,4),%xmm3
movups %xmm2,0x4(%rbx,%rdi,4)
movups %xmm3,0x14(%rbx,%rdi,4)
movups %xmm0,(%rbx,%rax,4)
movups %xmm1,0x10(%rbx,%rax,4)
cmp    %rdx,%r9
je     1143 <perfect_shuffle2+0x33>
add    %r10,%rdx
nopl   0x0(%rax)
sub    %edx,%r11d
mov    %rdx,%rax
test   $0x1,%r11b
je     13b6 <perfect_shuffle2+0x2a6>
lea    0x1(%rdx),%rax
mov    0x4(%rbx,%rdx,4),%ecx
lea    (%rdx,%r10,1),%rsi
add    $0x1,%rsi
mov    (%rbx,%rsi,4),%edi
mov    %edi,0x4(%rbx,%rdx,4)
mov    %ecx,(%rbx,%rsi,4)
not    %rdx
add    %rbp,%rdx
je     1143 <perfect_shuffle2+0x33>
lea    (%rbx,%r10,4),%rcx
add    $0x8,%rcx
nopw   0x0(%rax,%rax,1)
mov    0x4(%rbx,%rax,4),%edx
mov    -0x4(%rcx,%rax,4),%esi
mov    %esi,0x4(%rbx,%rax,4)
mov    %edx,-0x4(%rcx,%rax,4)
mov    0x8(%rbx,%rax,4),%edx
mov    (%rcx,%rax,4),%esi
mov    %esi,0x8(%rbx,%rax,4)
mov    %edx,(%rcx,%rax,4)
lea    0x2(%rax),%rdx
mov    %rdx,%rax
cmp    %rdx,%rbp
jne    13d0 <perfect_shuffle2+0x2c0>
jmp    1143 <perfect_shuffle2+0x33>
xor    %edi,%edi
test   $0x1,%r8b
jne    134c <perfect_shuffle2+0x23c>
jmp    137d <perfect_shuffle2+0x26d>
xor    %edi,%edi
test   $0x1,%r10b
jne    1217 <perfect_shuffle2+0x107>
jmp    122d <perfect_shuffle2+0x11d>

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

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