float dist(int i, int j, const int sites, const float nDouble, char **y) {
  int k, count;
  char *tipI = &(y[i + 1][1]);
  char *tipJ = &(y[j + 1][1]);
  for (k = 0, count = 0; k < sites; k++)
    if (tipI[k] == tipJ[k])
      count++;
  return (((float)count) * nDouble);
}


x86 assembly (clang, -O0):
<dist>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
movss  %xmm0,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x4(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
add    $0x1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
add    $0x1,%rax
mov    %rax,-0x30(%rbp)
movl   $0x0,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    119e <dist+0x9e>
mov    -0x28(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
mov    -0x30(%rbp),%rcx
movslq -0x1c(%rbp),%rdx
movsbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    118b <dist+0x8b>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    1190 <dist+0x90>
mov    -0x1c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x1c(%rbp)
jmp    1156 <dist+0x56>
cvtsi2ssl -0x20(%rbp),%xmm0
mulss  -0x10(%rbp),%xmm0
pop    %rbp
ret

x86 assembly (clang, -O2):
<dist>:
test   %edx,%edx
jle    1125 <dist+0x25>
movslq %edi,%rax
mov    0x8(%rcx,%rax,8),%r10
movslq %esi,%rsi
mov    0x8(%rcx,%rsi,8),%rcx
mov    %edx,%r9d
cmp    $0x8,%edx
jae    112d <dist+0x2d>
xor    %edx,%edx
xor    %esi,%esi
jmp    1280 <dist+0x180>
xorps  %xmm1,%xmm1
jmp    12a2 <dist+0x1a2>
mov    %r9d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rsi
mov    %rsi,%r8
shr    $0x3,%r8
add    $0x1,%r8
test   %rsi,%rsi
je     12aa <dist+0x1aa>
mov    %r8,%rsi
and    $0xfffffffffffffffe,%rsi
pxor   %xmm1,%xmm1
xor    %edi,%edi
movdqa 0xea0(%rip),%xmm3
pxor   %xmm2,%xmm2
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movd   0x1(%r10,%rdi,1),%xmm5
movd   0x5(%r10,%rdi,1),%xmm6
movd   0x1(%rcx,%rdi,1),%xmm4
pcmpeqb %xmm5,%xmm4
punpcklbw %xmm4,%xmm4
punpcklwd %xmm4,%xmm4
movd   0x5(%rcx,%rdi,1),%xmm5
pcmpeqb %xmm6,%xmm5
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
pand   %xmm3,%xmm4
paddd  %xmm1,%xmm4
pand   %xmm3,%xmm5
paddd  %xmm2,%xmm5
movd   0x9(%r10,%rdi,1),%xmm2
movd   0xd(%r10,%rdi,1),%xmm6
movd   0x9(%rcx,%rdi,1),%xmm1
pcmpeqb %xmm2,%xmm1
punpcklbw %xmm1,%xmm1
punpcklwd %xmm1,%xmm1
movd   0xd(%rcx,%rdi,1),%xmm2
pcmpeqb %xmm6,%xmm2
punpcklbw %xmm2,%xmm2
punpcklwd %xmm2,%xmm2
pand   %xmm3,%xmm1
paddd  %xmm4,%xmm1
pand   %xmm3,%xmm2
paddd  %xmm5,%xmm2
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rsi
jne    1170 <dist+0x70>
test   $0x1,%r8b
je     1252 <dist+0x152>
movd   0x1(%r10,%rdi,1),%xmm3
movd   0x5(%r10,%rdi,1),%xmm4
movd   0x1(%rcx,%rdi,1),%xmm5
pcmpeqb %xmm3,%xmm5
movd   0x5(%rcx,%rdi,1),%xmm3
pcmpeqb %xmm4,%xmm3
punpcklbw %xmm5,%xmm5
punpcklwd %xmm5,%xmm5
movdqa 0xdc6(%rip),%xmm4
pand   %xmm4,%xmm5
paddd  %xmm5,%xmm1
punpcklbw %xmm3,%xmm3
punpcklwd %xmm3,%xmm3
pand   %xmm4,%xmm3
paddd  %xmm3,%xmm2
paddd  %xmm2,%xmm1
pshufd $0xee,%xmm1,%xmm2
paddd  %xmm1,%xmm2
pshufd $0x55,%xmm2,%xmm1
paddd  %xmm2,%xmm1
movd   %xmm1,%esi
cmp    %r9,%rdx
je     129b <dist+0x19b>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl 0x1(%r10,%rdx,1),%eax
xor    %edi,%edi
cmp    0x1(%rcx,%rdx,1),%al
sete   %dil
add    %edi,%esi
add    $0x1,%rdx
cmp    %rdx,%r9
jne    1280 <dist+0x180>
xorps  %xmm1,%xmm1
cvtsi2ss %esi,%xmm1
mulss  %xmm0,%xmm1
movaps %xmm1,%xmm0
ret
pxor   %xmm1,%xmm1
xor    %edi,%edi
pxor   %xmm2,%xmm2
test   $0x1,%r8b
jne    1208 <dist+0x108>
jmp    1252 <dist+0x152>

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

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