int __attribute__((no, unused))
checkVd(const double *v, const double *e, int n) {
  int i;
  int err = 0;
  for (i = 0; i < n; i++)
    if (v[i] > (e[i] + (0.000001)) || v[i] < (e[i] - (0.000001)))
      if (e[i] != v[i]) {
        err++;
        ;
      }
  return err;
}


x86 assembly (clang, -O0):
<checkVd>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    11d1 <checkVd+0xd1>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  0xeba(%rip),%xmm1
addsd  (%rax,%rcx,8),%xmm1
ucomisd %xmm1,%xmm0
ja     1185 <checkVd+0x85>
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  0xe89(%rip),%xmm2
subsd  %xmm2,%xmm0
ucomisd %xmm1,%xmm0
jbe    11be <checkVd+0xbe>
mov    -0x10(%rbp),%rax
movslq -0x18(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x18(%rbp),%rcx
ucomisd (%rax,%rcx,8),%xmm0
jne    11b0 <checkVd+0xb0>
jp     11b0 <checkVd+0xb0>
jmp    11b9 <checkVd+0xb9>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    11be <checkVd+0xbe>
jmp    11c3 <checkVd+0xc3>
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x18(%rbp)
jmp    111d <checkVd+0x1d>
mov    -0x1c(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<checkVd>:
test   %edx,%edx
jle    1116 <checkVd+0x16>
mov    %edx,%r8d
cmp    $0x4,%edx
jae    1119 <checkVd+0x19>
xor    %r9d,%r9d
xor    %eax,%eax
jmp    11fc <checkVd+0xfc>
xor    %eax,%eax
ret
mov    %r8d,%r9d
and    $0xfffffffc,%r9d
lea    0x0(,%r8,8),%rax
and    $0xffffffffffffffe0,%rax
pxor   %xmm10,%xmm10
xor    %ecx,%ecx
movapd 0xec4(%rip),%xmm8
movapd 0xecb(%rip),%xmm9
pxor   %xmm11,%xmm11
nopw   0x0(%rax,%rax,1)
movupd (%rdi,%rcx,1),%xmm5
movupd 0x10(%rdi,%rcx,1),%xmm4
movupd (%rsi,%rcx,1),%xmm0
movupd 0x10(%rsi,%rcx,1),%xmm3
movapd %xmm0,%xmm6
addpd  %xmm8,%xmm6
movapd %xmm3,%xmm7
addpd  %xmm8,%xmm7
cmpltpd %xmm5,%xmm6
cmpltpd %xmm4,%xmm7
movapd %xmm0,%xmm2
addpd  %xmm9,%xmm2
movapd %xmm3,%xmm1
addpd  %xmm9,%xmm1
cmpneqpd %xmm5,%xmm0
cmpltpd %xmm2,%xmm5
orpd   %xmm6,%xmm5
cmpneqpd %xmm4,%xmm3
cmpltpd %xmm1,%xmm4
orpd   %xmm7,%xmm4
andpd  %xmm0,%xmm5
andpd  %xmm3,%xmm4
psrlq  $0x3f,%xmm5
psrlq  $0x3f,%xmm4
pshufd $0xe8,%xmm5,%xmm0
paddd  %xmm0,%xmm10
pshufd $0xe8,%xmm4,%xmm0
paddd  %xmm0,%xmm11
add    $0x20,%rcx
cmp    %rcx,%rax
jne    1150 <checkVd+0x50>
paddd  %xmm10,%xmm11
pshufd $0x55,%xmm11,%xmm0
paddd  %xmm11,%xmm0
movd   %xmm0,%eax
cmp    %r8,%r9
je     125a <checkVd+0x15a>
movsd  0xe1c(%rip),%xmm0
movsd  0xe1c(%rip),%xmm1
nopl   0x0(%rax)
movsd  (%rdi,%r9,8),%xmm2
movsd  (%rsi,%r9,8),%xmm3
movapd %xmm3,%xmm4
addsd  %xmm0,%xmm4
ucomisd %xmm4,%xmm2
seta   %cl
movapd %xmm3,%xmm4
addsd  %xmm1,%xmm4
ucomisd %xmm2,%xmm4
seta   %dl
or     %cl,%dl
ucomisd %xmm2,%xmm3
setp   %r10b
setne  %cl
or     %r10b,%cl
and    %dl,%cl
movzbl %cl,%ecx
add    %ecx,%eax
add    $0x1,%r9
cmp    %r9,%r8
jne    1210 <checkVd+0x110>
ret

LLVM IR (-O0):
define i32 @checkVd(double* %0, double* %1, i32 %2) {
%4 = alloca double*
%5 = alloca double*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
store double* %0, double** %4
store double* %1, double** %5
store i32 %2, i32* %6
store i32 0, i32* %8
store i32 0, i32* %7
br label %9
9: ; preds = %56, %3
%10 = load i32, i32* %7
%11 = load i32, i32* %6
%12 = icmp slt i32 %10, %11
br i1 %12, label %13, label %59
13: ; preds = %9
%14 = load double*, double** %4
%15 = load i32, i32* %7
%16 = sext i32 %15 to i64
%17 = getelementptr inbounds double, double* %14, i64 %16
%18 = load double, double* %17
%19 = load double*, double** %5
%20 = load i32, i32* %7
%21 = sext i32 %20 to i64
%22 = getelementptr inbounds double, double* %19, i64 %21
%23 = load double, double* %22
%24 = fadd double %23, 0x3EB0C6F7A0B5ED8D
%25 = fcmp ogt double %18, %24
br i1 %25, label %39, label %26
26: ; preds = %13
%27 = load double*, double** %4
%28 = load i32, i32* %7
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds double, double* %27, i64 %29
%31 = load double, double* %30
%32 = load double*, double** %5
%33 = load i32, i32* %7
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds double, double* %32, i64 %34
%36 = load double, double* %35
%37 = fsub double %36, 0x3EB0C6F7A0B5ED8D
%38 = fcmp olt double %31, %37
br i1 %38, label %39, label %55
39: ; preds = %26, %13
%40 = load double*, double** %5
%41 = load i32, i32* %7
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds double, double* %40, i64 %42
%44 = load double, double* %43
%45 = load double*, double** %4
%46 = load i32, i32* %7
%47 = sext i32 %46 to i64
%48 = getelementptr inbounds double, double* %45, i64 %47
%49 = load double, double* %48
%50 = fcmp une double %44, %49
br i1 %50, label %51, label %54
51: ; preds = %39
%52 = load i32, i32* %8
%53 = add nsw i32 %52, 1
store i32 %53, i32* %8
br label %54
54: ; preds = %51, %39
br label %55
55: ; preds = %54, %26
br label %56
56: ; preds = %55
%57 = load i32, i32* %7
%58 = add nsw i32 %57, 1
store i32 %58, i32* %7
br label %9
59: ; preds = %9
%60 = load i32, i32* %8
ret i32 %60
}

LLVM IR (-O2):
define i32 @checkVd(double* nocapture %0, double* nocapture %1, i32 %2) {
%4 = icmp sgt i32 %2, 0
br i1 %4, label %5, label %71
5: ; preds = %3
%6 = zext i32 %2 to i64
%7 = icmp ult i32 %2, 4
br i1 %7, label %50, label %8
8: ; preds = %5
%9 = and i64 %6, 4294967292
br label %10
10: ; preds = %10, %8
%11 = phi i64 [ 0, %8 ], [ %44, %10 ]
%12 = phi <2 x i32> [ zeroinitializer, %8 ], [ %42, %10 ]
%13 = phi <2 x i32> [ zeroinitializer, %8 ], [ %43, %10 ]
%14 = getelementptr inbounds double, double* %0, i64 %11
%15 = bitcast double* %14 to <2 x double>*
%16 = load <2 x double>, <2 x double>* %15
%17 = getelementptr inbounds double, double* %14, i64 2
%18 = bitcast double* %17 to <2 x double>*
%19 = load <2 x double>, <2 x double>* %18
%20 = getelementptr inbounds double, double* %1, i64 %11
%21 = bitcast double* %20 to <2 x double>*
%22 = load <2 x double>, <2 x double>* %21
%23 = getelementptr inbounds double, double* %20, i64 2
%24 = bitcast double* %23 to <2 x double>*
%25 = load <2 x double>, <2 x double>* %24
%26 = fadd <2 x double> %22, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
%27 = fadd <2 x double> %25, <double 0x3EB0C6F7A0B5ED8D, double 0x3EB0C6F7A0B5ED8D>
%28 = fcmp ogt <2 x double> %16, %26
%29 = fcmp ogt <2 x double> %19, %27
%30 = fadd <2 x double> %22, <double 0xBEB0C6F7A0B5ED8D, double 0xBEB0C6F7A0B5ED8D>
%31 = fadd <2 x double> %25, <double 0xBEB0C6F7A0B5ED8D, double 0xBEB0C6F7A0B5ED8D>
%32 = fcmp olt <2 x double> %16, %30
%33 = fcmp olt <2 x double> %19, %31
%34 = or <2 x i1> %28, %32
%35 = or <2 x i1> %29, %33
%36 = fcmp une <2 x double> %22, %16
%37 = fcmp une <2 x double> %25, %19
%38 = select <2 x i1> %34, <2 x i1> %36, <2 x i1> zeroinitializer
%39 = select <2 x i1> %35, <2 x i1> %37, <2 x i1> zeroinitializer
%40 = zext <2 x i1> %38 to <2 x i32>
%41 = zext <2 x i1> %39 to <2 x i32>
%42 = add <2 x i32> %12, %40
%43 = add <2 x i32> %13, %41
%44 = add nuw i64 %11, 4
%45 = icmp eq i64 %44, %9
br i1 %45, label %46, label %10
46: ; preds = %10
%47 = add <2 x i32> %43, %42
%48 = call i32 @llvm.vector.reduce.add.v2i32(<2 x i32> %47)
%49 = icmp eq i64 %9, %6
br i1 %49, label %71, label %50
50: ; preds = %5, %46
%51 = phi i64 [ 0, %5 ], [ %9, %46 ]
%52 = phi i32 [ 0, %5 ], [ %48, %46 ]
br label %53
53: ; preds = %50, %53
%54 = phi i64 [ %69, %53 ], [ %51, %50 ]
%55 = phi i32 [ %68, %53 ], [ %52, %50 ]
%56 = getelementptr inbounds double, double* %0, i64 %54
%57 = load double, double* %56
%58 = getelementptr inbounds double, double* %1, i64 %54
%59 = load double, double* %58
%60 = fadd double %59, 0x3EB0C6F7A0B5ED8D
%61 = fcmp ogt double %57, %60
%62 = fadd double %59, 0xBEB0C6F7A0B5ED8D
%63 = fcmp olt double %57, %62
%64 = or i1 %61, %63
%65 = fcmp une double %59, %57
%66 = select i1 %64, i1 %65, i1 false
%67 = zext i1 %66 to i32
%68 = add nuw nsw i32 %55, %67
%69 = add nuw nsw i64 %54, 1
%70 = icmp eq i64 %69, %6
br i1 %70, label %71, label %53
71: ; preds = %53, %46, %3
%72 = phi i32 [ 0, %3 ], [ %48, %46 ], [ %68, %53 ]
ret i32 %72
}