void intrlv(float *ri, float *r, float *i, int n, int iopt) {
  int n2, i1, i2;
  if (iopt == 1) {
    for (i1 = 1; i1 <= n; i1++) {
      i2 = i1 * 2;
      ri[i2 - 1] = r[i1];
      ri[i2] = i[i1];
    }
  } else if (iopt == -1) {
    n2 = n / 2;
    for (i1 = 1; i1 <= n2; i1++) {
      i2 = i1 * 2;
      r[i1] = ri[i2 - 1];
      i[i1] = ri[i2];
    }
  }
}


x86 assembly (clang, -O0):
<intrlv>:
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)
cmpl   $0x1,-0x20(%rbp)
jne    1189 <intrlv+0x89>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1184 <intrlv+0x84>
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1128 <intrlv+0x28>
jmp    120e <intrlv+0x10e>
cmpl   $0xffffffff,-0x20(%rbp)
jne    1209 <intrlv+0x109>
mov    -0x1c(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,-0x24(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1204 <intrlv+0x104>
mov    -0x28(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x2c(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11a8 <intrlv+0xa8>
jmp    1209 <intrlv+0x109>
jmp    120e <intrlv+0x10e>
pop    %rbp
ret

x86 assembly (clang, -O2):
<intrlv>:
push   %rbp
push   %r15
push   %r14
push   %r12
push   %rbx
cmp    $0xffffffff,%r8d
je     11ab <intrlv+0xab>
cmp    $0x1,%r8d
jne    141a <intrlv+0x31a>
test   %ecx,%ecx
jle    141a <intrlv+0x31a>
mov    %ecx,%r9d
lea    0x1(%r9),%r8
mov    $0x1,%eax
cmp    $0x4,%ecx
jae    1303 <intrlv+0x203>
mov    %rax,%rcx
not    %rcx
test   $0x1,%r8b
jne    115e <intrlv+0x5e>
movss  (%rsi,%rax,4),%xmm0
movss  %xmm0,-0x4(%rdi,%rax,8)
movss  (%rdx,%rax,4),%xmm0
movss  %xmm0,(%rdi,%rax,8)
add    $0x1,%rax
add    %r8,%rcx
je     141a <intrlv+0x31a>
nopw   0x0(%rax,%rax,1)
movss  (%rsi,%rax,4),%xmm0
movss  %xmm0,-0x4(%rdi,%rax,8)
movss  (%rdx,%rax,4),%xmm0
movss  %xmm0,(%rdi,%rax,8)
movss  0x4(%rsi,%rax,4),%xmm0
movss  %xmm0,0x4(%rdi,%rax,8)
movss  0x4(%rdx,%rax,4),%xmm0
movss  %xmm0,0x8(%rdi,%rax,8)
add    $0x2,%rax
cmp    %rax,%r8
jne    1170 <intrlv+0x70>
jmp    141a <intrlv+0x31a>
cmp    $0x2,%ecx
jl     141a <intrlv+0x31a>
shr    %ecx
lea    0x1(%rcx),%r8
mov    $0x1,%r10d
cmp    $0x8,%ecx
jb     1280 <intrlv+0x180>
lea    0x4(%rsi),%rax
lea    (%rsi,%r8,4),%r11
lea    0x4(%rdx),%r9
lea    (%rdx,%r8,4),%r14
lea    0x4(%rdi),%r15
lea    (%rdi,%r8,8),%rbx
add    $0xfffffffffffffffc,%rbx
cmp    %r14,%rax
setb   %bpl
cmp    %r11,%r9
setb   %r12b
cmp    %rbx,%rax
setb   %al
cmp    %r11,%r15
setb   %r11b
cmp    %rbx,%r9
setb   %r9b
cmp    %r14,%r15
setb   %bl
test   %r12b,%bpl
jne    1280 <intrlv+0x180>
and    %r11b,%al
jne    1280 <intrlv+0x180>
and    %bl,%r9b
jne    1280 <intrlv+0x180>
mov    %ecx,%r9d
and    $0xfffffff8,%r9d
lea    0x1(%r9),%r10
xor    %eax,%eax
nopl   0x0(%rax)
movups 0x4(%rdi,%rax,8),%xmm0
movups 0x14(%rdi,%rax,8),%xmm1
movups 0x24(%rdi,%rax,8),%xmm2
movups 0x34(%rdi,%rax,8),%xmm3
movaps %xmm0,%xmm4
shufps $0x88,%xmm1,%xmm4
movaps %xmm2,%xmm5
shufps $0x88,%xmm3,%xmm5
shufps $0xdd,%xmm1,%xmm0
shufps $0xdd,%xmm3,%xmm2
movups %xmm4,0x4(%rsi,%rax,4)
movups %xmm5,0x14(%rsi,%rax,4)
movups %xmm0,0x4(%rdx,%rax,4)
movups %xmm2,0x14(%rdx,%rax,4)
add    $0x8,%rax
cmp    %rax,%r9
jne    1230 <intrlv+0x130>
cmp    %r9,%rcx
je     141a <intrlv+0x31a>
mov    %r10,%rax
not    %rax
test   $0x1,%r8b
jne    12a9 <intrlv+0x1a9>
movss  -0x4(%rdi,%r10,8),%xmm0
movss  %xmm0,(%rsi,%r10,4)
movss  (%rdi,%r10,8),%xmm0
movss  %xmm0,(%rdx,%r10,4)
add    $0x1,%r10
add    %r8,%rax
je     141a <intrlv+0x31a>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  -0x4(%rdi,%r10,8),%xmm0
movss  %xmm0,(%rsi,%r10,4)
movss  (%rdi,%r10,8),%xmm0
movss  %xmm0,(%rdx,%r10,4)
movss  0x4(%rdi,%r10,8),%xmm0
movss  %xmm0,0x4(%rsi,%r10,4)
movss  0x8(%rdi,%r10,8),%xmm0
movss  %xmm0,0x4(%rdx,%r10,4)
add    $0x2,%r10
cmp    %r10,%r8
jne    12c0 <intrlv+0x1c0>
jmp    141a <intrlv+0x31a>
lea    0x4(%rdi),%rcx
lea    (%rdi,%r8,8),%rbx
add    $0xfffffffffffffffc,%rbx
lea    0x4(%rsi),%r10
lea    (%rsi,%r8,4),%r11
lea    0x4(%rdx),%r14
lea    (%rdx,%r8,4),%r15
cmp    %r11,%rcx
setb   %r11b
cmp    %rbx,%r10
setb   %r10b
cmp    %r15,%rcx
setb   %cl
cmp    %rbx,%r14
setb   %bl
test   %r10b,%r11b
jne    1139 <intrlv+0x39>
and    %bl,%cl
jne    1139 <intrlv+0x39>
mov    %r9d,%eax
and    $0xfffffffc,%eax
lea    -0x4(%rax),%rcx
mov    %rcx,%r10
shr    $0x2,%r10
add    $0x1,%r10
test   %rcx,%rcx
je     142c <intrlv+0x32c>
mov    %r10,%r11
and    $0xfffffffffffffffe,%r11
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  0x4(%rsi,%rcx,4),%xmm0
movsd  0xc(%rsi,%rcx,4),%xmm1
movsd  0x4(%rdx,%rcx,4),%xmm2
unpcklps %xmm2,%xmm0
movsd  0xc(%rdx,%rcx,4),%xmm2
unpcklps %xmm2,%xmm1
movups %xmm0,0x4(%rdi,%rcx,8)
movups %xmm1,0x14(%rdi,%rcx,8)
movsd  0x14(%rsi,%rcx,4),%xmm0
movsd  0x1c(%rsi,%rcx,4),%xmm1
movsd  0x14(%rdx,%rcx,4),%xmm2
unpcklps %xmm2,%xmm0
movsd  0x1c(%rdx,%rcx,4),%xmm2
unpcklps %xmm2,%xmm1
movups %xmm0,0x24(%rdi,%rcx,8)
movups %xmm1,0x34(%rdi,%rcx,8)
add    $0x8,%rcx
add    $0xfffffffffffffffe,%r11
jne    1380 <intrlv+0x280>
test   $0x1,%r10b
je     1415 <intrlv+0x315>
mov    %rcx,%rbx
or     $0x1,%rbx
shl    $0x3,%rcx
movsd  (%rsi,%rbx,4),%xmm0
movsd  0x8(%rsi,%rbx,4),%xmm1
movsd  (%rdx,%rbx,4),%xmm2
unpcklps %xmm2,%xmm0
movsd  0x8(%rdx,%rbx,4),%xmm2
unpcklps %xmm2,%xmm1
or     $0x18,%rcx
movups %xmm0,-0x4(%rdi,%rbx,8)
movups %xmm1,-0x4(%rdi,%rcx,1)
cmp    %rax,%r9
jne    1423 <intrlv+0x323>
pop    %rbx
pop    %r12
pop    %r14
pop    %r15
pop    %rbp
ret
or     $0x1,%rax
jmp    1139 <intrlv+0x39>
xor    %ecx,%ecx
test   $0x1,%r10b
jne    13e0 <intrlv+0x2e0>
jmp    1415 <intrlv+0x315>

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

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