void fn_invFDaubechiesWT2p2oneStage_NoaK(float *a_da, float *a4p_kaHF,
                                         float *a4p_kaLF,
                                         const unsigned int const cuci_N) {
  unsigned int ui_j;
  for (ui_j = 0; ui_j < cuci_N; ui_j = ui_j + 2) {
    a_da[ui_j] = (a4p_kaLF[ui_j >> 1]) * 0.707106781;
    a_da[ui_j + 1] = (a4p_kaLF[ui_j >> 1]) * 0.707106781;
    a_da[ui_j] = a_da[ui_j] + (a4p_kaHF[ui_j >> 1]) * 0.707106781;
    a_da[ui_j + 1] = a_da[ui_j + 1] - (a4p_kaHF[ui_j >> 1]) * 0.707106781;
  }
  return;
}


x86 assembly (clang, -O0):
<fn_invFDaubechiesWT2p2oneStage_NoaK>:
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
jae    1246 <fn_invFDaubechiesWT2p2oneStage_NoaK+0x146>
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
shr    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xebd(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x20(%rbp),%ecx
shr    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe8c(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
shr    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xe46(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%ecx
shr    $0x1,%ecx
mov    %ecx,%ecx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  0xde5(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x8(%rbp),%rax
mov    -0x20(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x20(%rbp)
jmp    111a <fn_invFDaubechiesWT2p2oneStage_NoaK+0x1a>
pop    %rbp
ret

x86 assembly (clang, -O2):
<fn_invFDaubechiesWT2p2oneStage_NoaK>:
push   %rbx
test   %ecx,%ecx
je     1295 <fn_invFDaubechiesWT2p2oneStage_NoaK+0x195>
mov    %ecx,%r9d
lea    -0x1(%r9),%r8
cmp    $0x2,%r8
jae    111d <fn_invFDaubechiesWT2p2oneStage_NoaK+0x1d>
xor    %ecx,%ecx
jmp    11e9 <fn_invFDaubechiesWT2p2oneStage_NoaK+0xe9>
lea    (%r9,%r9,1),%rax
add    $0xfffffffffffffffe,%rax
and    $0xfffffffffffffffc,%rax
lea    0x1(%r9),%rcx
and    $0xfffffffffffffffe,%rcx
lea    (%rdi,%rcx,4),%r10
lea    (%rdx,%rax,1),%rcx
add    $0x4,%rcx
cmp    %rdi,%rcx
seta   %r11b
add    %rsi,%rax
add    $0x4,%rax
cmp    %rdx,%r10
seta   %bl
cmp    %rdi,%rax
seta   %al
cmp    %rsi,%r10
seta   %r10b
xor    %ecx,%ecx
test   %bl,%r11b
jne    11e9 <fn_invFDaubechiesWT2p2oneStage_NoaK+0xe9>
and    %r10b,%al
jne    11e9 <fn_invFDaubechiesWT2p2oneStage_NoaK+0xe9>
shr    %r8
add    $0x1,%r8
mov    %r8,%r10
and    $0xfffffffffffffffe,%r10
lea    (%r10,%r10,1),%rcx
xor    %eax,%eax
movapd 0xe76(%rip),%xmm0
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rax,4),%rbx
and    $0xfffffffffffffff8,%rbx
cvtps2pd (%rdx,%rbx,1),%xmm1
mulpd  %xmm0,%xmm1
cvtpd2ps %xmm1,%xmm1
cvtps2pd %xmm1,%xmm2
unpcklps %xmm1,%xmm1
movupd %xmm1,(%rdi,%rax,8)
cvtps2pd (%rsi,%rbx,1),%xmm1
mulpd  %xmm0,%xmm1
movapd %xmm1,%xmm3
addpd  %xmm2,%xmm3
cvtpd2ps %xmm3,%xmm3
subpd  %xmm1,%xmm2
cvtpd2ps %xmm2,%xmm1
unpcklps %xmm1,%xmm3
movupd %xmm3,(%rdi,%rax,8)
add    $0x2,%rax
cmp    %rax,%r10
jne    1190 <fn_invFDaubechiesWT2p2oneStage_NoaK+0x90>
cmp    %r10,%r8
je     1295 <fn_invFDaubechiesWT2p2oneStage_NoaK+0x195>
lea    (%rdi,%rcx,4),%rdi
add    $0x4,%rdi
lea    (%rcx,%rcx,1),%rax
and    $0xfffffffffffffffc,%rax
add    %rax,%rdx
add    %rax,%rsi
xor    %eax,%eax
movsd  0xe07(%rip),%xmm0
nopl   0x0(%rax)
movss  (%rdx,%rax,2),%xmm1
cvtss2sd %xmm1,%xmm1
mulsd  %xmm0,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,-0x4(%rdi,%rax,4)
movss  (%rdx,%rax,2),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm0,%xmm2
cvtsd2ss %xmm2,%xmm2
movss  %xmm2,(%rdi,%rax,4)
cvtss2sd %xmm1,%xmm1
movss  (%rsi,%rax,2),%xmm3
cvtss2sd %xmm3,%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm1,%xmm3
xorps  %xmm1,%xmm1
cvtsd2ss %xmm3,%xmm1
movss  %xmm1,-0x4(%rdi,%rax,4)
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
movss  (%rsi,%rax,2),%xmm2
cvtss2sd %xmm2,%xmm2
mulsd  %xmm0,%xmm2
subsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
movss  %xmm1,(%rdi,%rax,4)
lea    (%rcx,%rax,1),%rbx
add    $0x2,%rbx
add    $0x2,%rax
cmp    %r9,%rbx
jb     1210 <fn_invFDaubechiesWT2p2oneStage_NoaK+0x110>
pop    %rbx
ret

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

LLVM IR (-O2):
define void @fn_invFDaubechiesWT2p2oneStage_NoaK(float* nocapture %0, float* nocapture %1, float* nocapture %2, i32 %3) {
%5 = icmp eq i32 %3, 0
br i1 %5, label %98, label %6
6: ; preds = %4
%7 = zext i32 %3 to i64
%8 = add nsw i64 %7, -1
%9 = lshr i64 %8, 1
%10 = add nuw i64 %9, 1
%11 = icmp ult i64 %8, 2
br i1 %11, label %67, label %12
12: ; preds = %6
%13 = add nsw i64 %7, -1
%14 = lshr i64 %13, 1
%15 = add nuw nsw i64 %7, 1
%16 = and i64 %15, 8589934590
%17 = getelementptr float, float* %0, i64 %16
%18 = add nuw i64 %14, 1
%19 = getelementptr float, float* %2, i64 %18
%20 = getelementptr float, float* %1, i64 %18
%21 = icmp ugt float* %19, %0
%22 = icmp ugt float* %17, %2
%23 = and i1 %21, %22
%24 = icmp ugt float* %20, %0
%25 = icmp ugt float* %17, %1
%26 = and i1 %24, %25
%27 = or i1 %23, %26
br i1 %27, label %67, label %28
28: ; preds = %12
%29 = and i64 %10, -2
%30 = shl i64 %29, 1
%31 = getelementptr inbounds float, float* %0, i64 -1
br label %32
32: ; preds = %32, %28
%33 = phi i64 [ 0, %28 ], [ %63, %32 ]
%34 = shl i64 %33, 1
%35 = and i64 %33, 9223372036854775806
%36 = getelementptr inbounds float, float* %2, i64 %35
%37 = bitcast float* %36 to <2 x float>*
%38 = load <2 x float>, <2 x float>* %37
%39 = fpext <2 x float> %38 to <2 x double>
%40 = fmul <2 x double> %39, <double 0x3FE6A09E6665983E, double 0x3FE6A09E6665983E>
%41 = fptrunc <2 x double> %40 to <2 x float>
%42 = fpext <2 x float> %38 to <2 x double>
%43 = fmul <2 x double> %42, <double 0x3FE6A09E6665983E, double 0x3FE6A09E6665983E>
%44 = fptrunc <2 x double> %43 to <2 x float>
%45 = or i64 %34, 1
%46 = getelementptr inbounds float, float* %31, i64 %45
%47 = bitcast float* %46 to <4 x float>*
%48 = shufflevector <2 x float> %41, <2 x float> %44, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x float> %48, <4 x float>* %47
%49 = fpext <2 x float> %41 to <2 x double>
%50 = getelementptr inbounds float, float* %1, i64 %35
%51 = bitcast float* %50 to <2 x float>*
%52 = load <2 x float>, <2 x float>* %51
%53 = fpext <2 x float> %52 to <2 x double>
%54 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %53, <2 x double> <double 0x3FE6A09E6665983E, double 0x3FE6A09E6665983E>, <2 x double> %49)
%55 = fptrunc <2 x double> %54 to <2 x float>
%56 = fpext <2 x float> %44 to <2 x double>
%57 = fpext <2 x float> %52 to <2 x double>
%58 = fneg <2 x double> %57
%59 = call <2 x double> @llvm.fmuladd.v2f64(<2 x double> %58, <2 x double> <double 0x3FE6A09E6665983E, double 0x3FE6A09E6665983E>, <2 x double> %56)
%60 = fptrunc <2 x double> %59 to <2 x float>
%61 = bitcast float* %46 to <4 x float>*
%62 = shufflevector <2 x float> %55, <2 x float> %60, <4 x i32> <i32 0, i32 2, i32 1, i32 3>
store <4 x float> %62, <4 x float>* %61
%63 = add nuw i64 %33, 2
%64 = icmp eq i64 %63, %29
br i1 %64, label %65, label %32
65: ; preds = %32
%66 = icmp eq i64 %10, %29
br i1 %66, label %98, label %67
67: ; preds = %12, %6, %65
%68 = phi i64 [ 0, %12 ], [ 0, %6 ], [ %30, %65 ]
br label %69
69: ; preds = %67, %69
%70 = phi i64 [ %96, %69 ], [ %68, %67 ]
%71 = lshr exact i64 %70, 1
%72 = getelementptr inbounds float, float* %2, i64 %71
%73 = load float, float* %72
%74 = fpext float %73 to double
%75 = fmul double %74, 0x3FE6A09E6665983E
%76 = fptrunc double %75 to float
%77 = getelementptr inbounds float, float* %0, i64 %70
store float %76, float* %77
%78 = load float, float* %72
%79 = fpext float %78 to double
%80 = fmul double %79, 0x3FE6A09E6665983E
%81 = fptrunc double %80 to float
%82 = or i64 %70, 1
%83 = getelementptr inbounds float, float* %0, i64 %82
store float %81, float* %83
%84 = fpext float %76 to double
%85 = getelementptr inbounds float, float* %1, i64 %71
%86 = load float, float* %85
%87 = fpext float %86 to double
%88 = tail call double @llvm.fmuladd.f64(double %87, double 0x3FE6A09E6665983E, double %84)
%89 = fptrunc double %88 to float
store float %89, float* %77
%90 = fpext float %81 to double
%91 = load float, float* %85
%92 = fpext float %91 to double
%93 = fneg double %92
%94 = tail call double @llvm.fmuladd.f64(double %93, double 0x3FE6A09E6665983E, double %90)
%95 = fptrunc double %94 to float
store float %95, float* %83
%96 = add nuw nsw i64 %70, 2
%97 = icmp ult i64 %96, %7
br i1 %97, label %69, label %98
98: ; preds = %69, %65, %4
ret void
}