void symevn(n, v, u) int n;
float v[], u[];
{
  float *vp, *up, *vn = v + n;
  for (vp = v, up = u; vp < vn; vp++, up++)
    *up = *vp;
  for (vp = vn - 1; vp >= v; vp--, up++)
    *up = *vp;
}


x86 assembly (clang, -O0):
<symevn>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x4(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x30(%rbp),%rax
jae    116d <symevn+0x6d>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
jmp    1132 <symevn+0x32>
mov    -0x30(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
cmp    -0x10(%rbp),%rax
jb     11b4 <symevn+0xb4>
mov    -0x20(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x28(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x28(%rbp)
jmp    1179 <symevn+0x79>
pop    %rbp
ret

x86 assembly (clang, -O2):
<symevn>:
movslq %edi,%rcx
lea    (%rsi,%rcx,4),%rax
test   %ecx,%ecx
jle    127c <symevn+0x17c>
lea    0x4(%rsi),%rcx
cmp    %rcx,%rax
mov    %rcx,%r9
cmova  %rax,%r9
mov    %rsi,%rdi
not    %rdi
add    %rdi,%r9
cmp    $0x1c,%r9
jae    1134 <symevn+0x34>
mov    %rsi,%rcx
jmp    1250 <symevn+0x150>
cmp    %rcx,%rax
cmova  %rax,%rcx
add    %rdi,%rcx
and    $0xfffffffffffffffc,%rcx
lea    (%rsi,%rcx,1),%rdi
add    $0x4,%rdi
cmp    %rdx,%rdi
jbe    1163 <symevn+0x63>
add    %rdx,%rcx
add    $0x4,%rcx
cmp    %rsi,%rcx
jbe    1163 <symevn+0x63>
mov    %rsi,%rcx
jmp    1250 <symevn+0x150>
shr    $0x2,%r9
add    $0x1,%r9
mov    %r9,%r8
and    $0xfffffffffffffff8,%r8
lea    -0x8(%r8),%rcx
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%r10d
and    $0x3,%r10d
cmp    $0x18,%rcx
jae    1192 <symevn+0x92>
xor    %ecx,%ecx
jmp    11f8 <symevn+0xf8>
and    $0xfffffffffffffffc,%rdi
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movups (%rsi,%rcx,4),%xmm0
movups 0x10(%rsi,%rcx,4),%xmm1
movups %xmm0,(%rdx,%rcx,4)
movups %xmm1,0x10(%rdx,%rcx,4)
movups 0x20(%rsi,%rcx,4),%xmm0
movups 0x30(%rsi,%rcx,4),%xmm1
movups %xmm0,0x20(%rdx,%rcx,4)
movups %xmm1,0x30(%rdx,%rcx,4)
movups 0x40(%rsi,%rcx,4),%xmm0
movups 0x50(%rsi,%rcx,4),%xmm1
movups %xmm0,0x40(%rdx,%rcx,4)
movups %xmm1,0x50(%rdx,%rcx,4)
movups 0x60(%rsi,%rcx,4),%xmm0
movups 0x70(%rsi,%rcx,4),%xmm1
movups %xmm0,0x60(%rdx,%rcx,4)
movups %xmm1,0x70(%rdx,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdi
jne    11a0 <symevn+0xa0>
test   %r10,%r10
je     123d <symevn+0x13d>
lea    (%rdx,%rcx,4),%r11
add    $0x10,%r11
lea    (%rsi,%rcx,4),%rcx
add    $0x10,%rcx
shl    $0x5,%r10
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x10(%rcx,%rdi,1),%xmm0
movups (%rcx,%rdi,1),%xmm1
movups %xmm0,-0x10(%r11,%rdi,1)
movups %xmm1,(%r11,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%r10
jne    1220 <symevn+0x120>
lea    (%rdx,%r8,4),%rdx
cmp    %r8,%r9
je     127c <symevn+0x17c>
lea    (%rsi,%r8,4),%rcx
nopw   0x0(%rax,%rax,1)
movss  (%rcx),%xmm0
movss  %xmm0,(%rdx)
add    $0x4,%rcx
add    $0x4,%rdx
cmp    %rax,%rcx
jb     1250 <symevn+0x150>
jmp    127c <symevn+0x17c>
nopw   0x0(%rax,%rax,1)
movss  (%rax),%xmm0
movss  %xmm0,(%rdx)
add    $0x4,%rdx
add    $0xfffffffffffffffc,%rax
cmp    %rsi,%rax
jae    1270 <symevn+0x170>
ret

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

LLVM IR (-O2):
define void @symevn(i32 %0, float* %1, float* nocapture writeonly %2) {
%4 = ptrtoint float* %1 to i64
%5 = ptrtoint float* %1 to i64
%6 = sext i32 %0 to i64
%7 = getelementptr inbounds float, float* %1, i64 %6
%8 = icmp sgt i32 %0, 0
br i1 %8, label %9, label %117
9: ; preds = %3
%10 = shl nsw i64 %6, 2
%11 = add i64 %10, %4
%12 = add i64 %4, 4
%13 = call i64 @llvm.umax.i64(i64 %11, i64 %12)
%14 = xor i64 %4, -1
%15 = add i64 %13, %14
%16 = lshr i64 %15, 2
%17 = add nuw nsw i64 %16, 1
%18 = icmp ult i64 %15, 28
br i1 %18, label %114, label %19
19: ; preds = %9
%20 = shl nsw i64 %6, 2
%21 = add i64 %20, %5
%22 = add i64 %5, 4
%23 = call i64 @llvm.umax.i64(i64 %21, i64 %22)
%24 = xor i64 %5, -1
%25 = add i64 %23, %24
%26 = lshr i64 %25, 2
%27 = add nuw nsw i64 %26, 1
%28 = getelementptr float, float* %2, i64 %27
%29 = getelementptr float, float* %1, i64 %27
%30 = icmp ugt float* %29, %2
%31 = icmp ugt float* %28, %1
%32 = and i1 %30, %31
br i1 %32, label %114, label %33
33: ; preds = %19
%34 = and i64 %17, 9223372036854775800
%35 = getelementptr float, float* %1, i64 %34
%36 = getelementptr float, float* %2, i64 %34
%37 = add nsw i64 %34, -8
%38 = lshr exact i64 %37, 3
%39 = add nuw nsw i64 %38, 1
%40 = and i64 %39, 3
%41 = icmp ult i64 %37, 24
br i1 %41, label %93, label %42
42: ; preds = %33
%43 = and i64 %39, 4611686018427387900
br label %44
44: ; preds = %44, %42
%45 = phi i64 [ 0, %42 ], [ %90, %44 ]
%46 = phi i64 [ 0, %42 ], [ %91, %44 ]
%47 = getelementptr float, float* %1, i64 %45
%48 = getelementptr float, float* %2, i64 %45
%49 = bitcast float* %47 to <4 x float>*
%50 = load <4 x float>, <4 x float>* %49
%51 = getelementptr float, float* %47, i64 4
%52 = bitcast float* %51 to <4 x float>*
%53 = load <4 x float>, <4 x float>* %52
%54 = bitcast float* %48 to <4 x float>*
store <4 x float> %50, <4 x float>* %54
%55 = getelementptr float, float* %48, i64 4
%56 = bitcast float* %55 to <4 x float>*
store <4 x float> %53, <4 x float>* %56
%57 = or i64 %45, 8
%58 = getelementptr float, float* %1, i64 %57
%59 = getelementptr float, float* %2, i64 %57
%60 = bitcast float* %58 to <4 x float>*
%61 = load <4 x float>, <4 x float>* %60
%62 = getelementptr float, float* %58, i64 4
%63 = bitcast float* %62 to <4 x float>*
%64 = load <4 x float>, <4 x float>* %63
%65 = bitcast float* %59 to <4 x float>*
store <4 x float> %61, <4 x float>* %65
%66 = getelementptr float, float* %59, i64 4
%67 = bitcast float* %66 to <4 x float>*
store <4 x float> %64, <4 x float>* %67
%68 = or i64 %45, 16
%69 = getelementptr float, float* %1, i64 %68
%70 = getelementptr float, float* %2, i64 %68
%71 = bitcast float* %69 to <4 x float>*
%72 = load <4 x float>, <4 x float>* %71
%73 = getelementptr float, float* %69, i64 4
%74 = bitcast float* %73 to <4 x float>*
%75 = load <4 x float>, <4 x float>* %74
%76 = bitcast float* %70 to <4 x float>*
store <4 x float> %72, <4 x float>* %76
%77 = getelementptr float, float* %70, i64 4
%78 = bitcast float* %77 to <4 x float>*
store <4 x float> %75, <4 x float>* %78
%79 = or i64 %45, 24
%80 = getelementptr float, float* %1, i64 %79
%81 = getelementptr float, float* %2, i64 %79
%82 = bitcast float* %80 to <4 x float>*
%83 = load <4 x float>, <4 x float>* %82
%84 = getelementptr float, float* %80, i64 4
%85 = bitcast float* %84 to <4 x float>*
%86 = load <4 x float>, <4 x float>* %85
%87 = bitcast float* %81 to <4 x float>*
store <4 x float> %83, <4 x float>* %87
%88 = getelementptr float, float* %81, i64 4
%89 = bitcast float* %88 to <4 x float>*
store <4 x float> %86, <4 x float>* %89
%90 = add nuw i64 %45, 32
%91 = add i64 %46, 4
%92 = icmp eq i64 %91, %43
br i1 %92, label %93, label %44
93: ; preds = %44, %33
%94 = phi i64 [ 0, %33 ], [ %90, %44 ]
%95 = icmp eq i64 %40, 0
br i1 %95, label %112, label %96
96: ; preds = %93, %96
%97 = phi i64 [ %109, %96 ], [ %94, %93 ]
%98 = phi i64 [ %110, %96 ], [ 0, %93 ]
%99 = getelementptr float, float* %1, i64 %97
%100 = getelementptr float, float* %2, i64 %97
%101 = bitcast float* %99 to <4 x float>*
%102 = load <4 x float>, <4 x float>* %101
%103 = getelementptr float, float* %99, i64 4
%104 = bitcast float* %103 to <4 x float>*
%105 = load <4 x float>, <4 x float>* %104
%106 = bitcast float* %100 to <4 x float>*
store <4 x float> %102, <4 x float>* %106
%107 = getelementptr float, float* %100, i64 4
%108 = bitcast float* %107 to <4 x float>*
store <4 x float> %105, <4 x float>* %108
%109 = add nuw i64 %97, 8
%110 = add i64 %98, 1
%111 = icmp eq i64 %110, %40
br i1 %111, label %112, label %96
112: ; preds = %96, %93
%113 = icmp eq i64 %17, %34
br i1 %113, label %117, label %114
114: ; preds = %19, %9, %112
%115 = phi float* [ %1, %19 ], [ %1, %9 ], [ %35, %112 ]
%116 = phi float* [ %2, %19 ], [ %2, %9 ], [ %36, %112 ]
br label %121
117: ; preds = %121, %112, %3
%118 = phi float* [ %2, %3 ], [ %36, %112 ], [ %126, %121 ]
%119 = getelementptr inbounds float, float* %7, i64 -1
%120 = icmp ult float* %119, %1
br i1 %120, label %135, label %128
121: ; preds = %114, %121
%122 = phi float* [ %125, %121 ], [ %115, %114 ]
%123 = phi float* [ %126, %121 ], [ %116, %114 ]
%124 = load float, float* %122
store float %124, float* %123
%125 = getelementptr inbounds float, float* %122, i64 1
%126 = getelementptr inbounds float, float* %123, i64 1
%127 = icmp ult float* %125, %7
br i1 %127, label %121, label %117
128: ; preds = %117, %128
%129 = phi float* [ %133, %128 ], [ %119, %117 ]
%130 = phi float* [ %132, %128 ], [ %118, %117 ]
%131 = load float, float* %129
store float %131, float* %130
%132 = getelementptr inbounds float, float* %130, i64 1
%133 = getelementptr inbounds float, float* %129, i64 -1
%134 = icmp ult float* %133, %1
br i1 %134, label %135, label %128
135: ; preds = %128, %117
ret void
}