float calc_hyperplane_c(float *vector1, float *vector2, float *hyperplane,
                        int dim) {
  int i;
  float diff;
  double sum;
  double sum2;
  float val;
  sum = 0.0;
  sum2 = 0.0;
  for (i = 0; i < dim; i++) {
    diff = vector2[i] - vector1[i];
    hyperplane[i] = (float)diff;
    sum += diff * diff;
    sum2 += (vector1[i]) * (vector1[i]) - (vector2[i]) * (vector2[i]);
  }
  if (sum != 0.0) {
    double d;
    d = 1.0 / sqrt((double)sum);
    for (i = 0; i < dim; i++) {
      hyperplane[i] = (float)(hyperplane[i] * d);
    }
    val = (float)(0.5 * d * ((double)sum2));
  } else {
    val = 0.0;
  }
  return val;
}


x86 assembly (clang, -O0):
<calc_hyperplane_c>:
push   %rbp
mov    %rsp,%rbp
sub    $0x50,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x38(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    11f8 <calc_hyperplane_c+0xe8>
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x24(%rbp)
movss  -0x24(%rbp),%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
movss  -0x24(%rbp),%xmm0
mulss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x30(%rbp),%xmm0
movsd  %xmm0,-0x30(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x20(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm1
movd   %xmm1,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x38(%rbp),%xmm0
movsd  %xmm0,-0x38(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    113e <calc_hyperplane_c+0x2e>
movsd  -0x30(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1215 <calc_hyperplane_c+0x105>
jp     1215 <calc_hyperplane_c+0x105>
jmp    129b <calc_hyperplane_c+0x18b>
movsd  -0x30(%rbp),%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xdd6(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jge    127b <calc_hyperplane_c+0x16b>
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  -0x48(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    123a <calc_hyperplane_c+0x12a>
movsd  0xd85(%rip),%xmm0
mulsd  -0x48(%rbp),%xmm0
mulsd  -0x38(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
jmp    12a3 <calc_hyperplane_c+0x193>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
add    $0x50,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<calc_hyperplane_c>:
push   %rbp
push   %r14
push   %rbx
sub    $0x10,%rsp
xorps  %xmm0,%xmm0
test   %ecx,%ecx
jle    1332 <calc_hyperplane_c+0x222>
mov    %ecx,%r14d
mov    %rdx,%rbx
mov    %ecx,%ebp
xorpd  %xmm6,%xmm6
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rsi,%rax,4),%xmm1
subss  (%rdi,%rax,4),%xmm1
movss  %xmm1,(%rbx,%rax,4)
mulss  %xmm1,%xmm1
movss  (%rdi,%rax,4),%xmm2
movss  (%rsi,%rax,4),%xmm3
mulss  %xmm3,%xmm3
mulss  %xmm2,%xmm2
subss  %xmm3,%xmm2
unpcklps %xmm1,%xmm2
cvtps2pd %xmm2,%xmm1
addpd  %xmm1,%xmm6
add    $0x1,%rax
cmp    %rax,%rbp
jne    1140 <calc_hyperplane_c+0x30>
movapd %xmm6,%xmm1
unpckhpd %xmm6,%xmm1
xorps  %xmm2,%xmm2
ucomisd %xmm2,%xmm1
jne    1193 <calc_hyperplane_c+0x83>
jnp    1332 <calc_hyperplane_c+0x222>
ucomisd %xmm2,%xmm1
jb     11a2 <calc_hyperplane_c+0x92>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
jmp    11b5 <calc_hyperplane_c+0xa5>
movapd %xmm1,%xmm0
movapd %xmm6,(%rsp)
call   1030 <sqrt@plt>
movapd (%rsp),%xmm6
movsd  0xe43(%rip),%xmm1
divsd  %xmm0,%xmm1
test   %r14d,%r14d
jle    131f <calc_hyperplane_c+0x20f>
cmp    $0x8,%r14d
jae    11d7 <calc_hyperplane_c+0xc7>
xor    %eax,%eax
jmp    1300 <calc_hyperplane_c+0x1f0>
mov    %ebp,%eax
and    $0xfffffff8,%eax
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     133b <calc_hyperplane_c+0x22b>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
cvtps2pd 0x8(%rbx,%rcx,4),%xmm2
cvtps2pd (%rbx,%rcx,4),%xmm3
cvtps2pd 0x18(%rbx,%rcx,4),%xmm4
cvtps2pd 0x10(%rbx,%rcx,4),%xmm5
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm5
mulpd  %xmm0,%xmm4
cvtpd2ps %xmm2,%xmm2
cvtpd2ps %xmm3,%xmm3
cvtpd2ps %xmm4,%xmm4
unpcklpd %xmm2,%xmm3
cvtpd2ps %xmm5,%xmm2
unpcklpd %xmm4,%xmm2
movupd %xmm3,(%rbx,%rcx,4)
movupd %xmm2,0x10(%rbx,%rcx,4)
cvtps2pd 0x28(%rbx,%rcx,4),%xmm2
cvtps2pd 0x20(%rbx,%rcx,4),%xmm3
cvtps2pd 0x38(%rbx,%rcx,4),%xmm4
cvtps2pd 0x30(%rbx,%rcx,4),%xmm5
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm5
mulpd  %xmm0,%xmm4
cvtpd2ps %xmm2,%xmm2
cvtpd2ps %xmm3,%xmm3
cvtpd2ps %xmm4,%xmm4
unpcklpd %xmm2,%xmm3
cvtpd2ps %xmm5,%xmm2
unpcklpd %xmm4,%xmm2
movupd %xmm3,0x20(%rbx,%rcx,4)
movupd %xmm2,0x30(%rbx,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1210 <calc_hyperplane_c+0x100>
test   $0x1,%dl
je     12f7 <calc_hyperplane_c+0x1e7>
cvtps2pd 0x8(%rbx,%rcx,4),%xmm2
cvtps2pd (%rbx,%rcx,4),%xmm3
cvtps2pd 0x18(%rbx,%rcx,4),%xmm4
cvtps2pd 0x10(%rbx,%rcx,4),%xmm5
mulpd  %xmm0,%xmm3
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm5
mulpd  %xmm0,%xmm4
cvtpd2ps %xmm2,%xmm0
cvtpd2ps %xmm3,%xmm2
cvtpd2ps %xmm4,%xmm3
cvtpd2ps %xmm5,%xmm4
unpcklpd %xmm0,%xmm2
unpcklpd %xmm3,%xmm4
movupd %xmm2,(%rbx,%rcx,4)
movupd %xmm4,0x10(%rbx,%rcx,4)
cmp    %rbp,%rax
je     131f <calc_hyperplane_c+0x20f>
nopl   0x0(%rax)
movss  (%rbx,%rax,4),%xmm0
cvtss2sd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rbx,%rax,4)
add    $0x1,%rax
cmp    %rax,%rbp
jne    1300 <calc_hyperplane_c+0x1f0>
mulsd  0xce1(%rip),%xmm1
mulsd  %xmm1,%xmm6
xorps  %xmm0,%xmm0
cvtsd2ss %xmm6,%xmm0
add    $0x10,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret
xor    %ecx,%ecx
test   $0x1,%dl
jne    12b1 <calc_hyperplane_c+0x1a1>
jmp    12f7 <calc_hyperplane_c+0x1e7>

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

LLVM IR (-O2):
define float @calc_hyperplane_c(float* nocapture %0, float* nocapture %1, float* nocapture %2, i32 %3) {
%5 = icmp sgt i32 %3, 0
br i1 %5, label %6, label %122
6: ; preds = %4
%7 = zext i32 %3 to i64
br label %8
8: ; preds = %6, %8
%9 = phi i64 [ 0, %6 ], [ %27, %8 ]
%10 = phi <2 x double> [ zeroinitializer, %6 ], [ %26, %8 ]
%11 = getelementptr inbounds float, float* %1, i64 %9
%12 = load float, float* %11
%13 = getelementptr inbounds float, float* %0, i64 %9
%14 = load float, float* %13
%15 = fsub float %12, %14
%16 = getelementptr inbounds float, float* %2, i64 %9
store float %15, float* %16
%17 = fmul float %15, %15
%18 = load float, float* %13
%19 = load float, float* %11
%20 = fneg float %19
%21 = fmul float %19, %20
%22 = tail call float @llvm.fmuladd.f32(float %18, float %18, float %21)
%23 = insertelement <2 x float> poison, float %22, i64 0
%24 = insertelement <2 x float> %23, float %17, i64 1
%25 = fpext <2 x float> %24 to <2 x double>
%26 = fadd <2 x double> %10, %25
%27 = add nuw nsw i64 %9, 1
%28 = icmp eq i64 %27, %7
br i1 %28, label %29, label %8
29: ; preds = %8
%30 = extractelement <2 x double> %26, i64 1
%31 = fcmp une double %30, 0.000000e+00
br i1 %31, label %32, label %122
32: ; preds = %29
%33 = tail call double @sqrt(double %30)
%34 = fdiv double 1.000000e+00, %33
br i1 %5, label %35, label %117
35: ; preds = %32
%36 = zext i32 %3 to i64
%37 = icmp ult i32 %3, 8
br i1 %37, label %106, label %38
38: ; preds = %35
%39 = and i64 %7, 4294967288
%40 = insertelement <4 x double> poison, double %34, i64 0
%41 = shufflevector <4 x double> %40, <4 x double> poison, <4 x i32> zeroinitializer
%42 = insertelement <4 x double> poison, double %34, i64 0
%43 = shufflevector <4 x double> %42, <4 x double> poison, <4 x i32> zeroinitializer
%44 = add nsw i64 %39, -8
%45 = lshr exact i64 %44, 3
%46 = add nuw nsw i64 %45, 1
%47 = and i64 %46, 1
%48 = icmp eq i64 %44, 0
br i1 %48, label %86, label %49
49: ; preds = %38
%50 = and i64 %46, 4611686018427387902
br label %51
51: ; preds = %51, %49
%52 = phi i64 [ 0, %49 ], [ %83, %51 ]
%53 = phi i64 [ 0, %49 ], [ %84, %51 ]
%54 = getelementptr inbounds float, float* %2, i64 %52
%55 = bitcast float* %54 to <4 x float>*
%56 = load <4 x float>, <4 x float>* %55
%57 = getelementptr inbounds float, float* %54, i64 4
%58 = bitcast float* %57 to <4 x float>*
%59 = load <4 x float>, <4 x float>* %58
%60 = fpext <4 x float> %56 to <4 x double>
%61 = fpext <4 x float> %59 to <4 x double>
%62 = fmul <4 x double> %41, %60
%63 = fmul <4 x double> %43, %61
%64 = fptrunc <4 x double> %62 to <4 x float>
%65 = fptrunc <4 x double> %63 to <4 x float>
%66 = bitcast float* %54 to <4 x float>*
store <4 x float> %64, <4 x float>* %66
%67 = bitcast float* %57 to <4 x float>*
store <4 x float> %65, <4 x float>* %67
%68 = or i64 %52, 8
%69 = getelementptr inbounds float, float* %2, i64 %68
%70 = bitcast float* %69 to <4 x float>*
%71 = load <4 x float>, <4 x float>* %70
%72 = getelementptr inbounds float, float* %69, i64 4
%73 = bitcast float* %72 to <4 x float>*
%74 = load <4 x float>, <4 x float>* %73
%75 = fpext <4 x float> %71 to <4 x double>
%76 = fpext <4 x float> %74 to <4 x double>
%77 = fmul <4 x double> %41, %75
%78 = fmul <4 x double> %43, %76
%79 = fptrunc <4 x double> %77 to <4 x float>
%80 = fptrunc <4 x double> %78 to <4 x float>
%81 = bitcast float* %69 to <4 x float>*
store <4 x float> %79, <4 x float>* %81
%82 = bitcast float* %72 to <4 x float>*
store <4 x float> %80, <4 x float>* %82
%83 = add nuw i64 %52, 16
%84 = add i64 %53, 2
%85 = icmp eq i64 %84, %50
br i1 %85, label %86, label %51
86: ; preds = %51, %38
%87 = phi i64 [ 0, %38 ], [ %83, %51 ]
%88 = icmp eq i64 %47, 0
br i1 %88, label %104, label %89
89: ; preds = %86
%90 = getelementptr inbounds float, float* %2, i64 %87
%91 = bitcast float* %90 to <4 x float>*
%92 = load <4 x float>, <4 x float>* %91
%93 = getelementptr inbounds float, float* %90, i64 4
%94 = bitcast float* %93 to <4 x float>*
%95 = load <4 x float>, <4 x float>* %94
%96 = fpext <4 x float> %92 to <4 x double>
%97 = fpext <4 x float> %95 to <4 x double>
%98 = fmul <4 x double> %41, %96
%99 = fmul <4 x double> %43, %97
%100 = fptrunc <4 x double> %98 to <4 x float>
%101 = fptrunc <4 x double> %99 to <4 x float>
%102 = bitcast float* %90 to <4 x float>*
store <4 x float> %100, <4 x float>* %102
%103 = bitcast float* %93 to <4 x float>*
store <4 x float> %101, <4 x float>* %103
br label %104
104: ; preds = %86, %89
%105 = icmp eq i64 %39, %7
br i1 %105, label %117, label %106
106: ; preds = %35, %104
%107 = phi i64 [ 0, %35 ], [ %39, %104 ]
br label %108
108: ; preds = %106, %108
%109 = phi i64 [ %115, %108 ], [ %107, %106 ]
%110 = getelementptr inbounds float, float* %2, i64 %109
%111 = load float, float* %110
%112 = fpext float %111 to double
%113 = fmul double %34, %112
%114 = fptrunc double %113 to float
store float %114, float* %110
%115 = add nuw nsw i64 %109, 1
%116 = icmp eq i64 %115, %36
br i1 %116, label %117, label %108
117: ; preds = %108, %104, %32
%118 = fmul double %34, 5.000000e-01
%119 = extractelement <2 x double> %26, i64 0
%120 = fmul double %119, %118
%121 = fptrunc double %120 to float
br label %122
122: ; preds = %4, %29, %117
%123 = phi float [ %121, %117 ], [ 0.000000e+00, %29 ], [ 0.000000e+00, %4 ]
ret float %123
}