double transpec_diffpoint(long pos, long chan, double diff, const int nchan,
                          const long imsize, const double *image) {
  long w;
  double temp = 0;
  for (w = 0; w < nchan; w++) {
    if (w == chan)
      temp +=
          (image[w * imsize + pos] + diff) * (image[w * imsize + pos] + diff);
    else
      temp += (image[w * imsize + pos]) * (image[w * imsize + pos]);
  }
  return sqrt(temp);
}


x86 assembly (clang, -O0):
<transpec_diffpoint>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movsd  %xmm0,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x40(%rbp)
movq   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%rax
movslq -0x1c(%rbp),%rcx
cmp    %rcx,%rax
jge    1200 <transpec_diffpoint+0xf0>
mov    -0x38(%rbp),%rax
cmp    -0x10(%rbp),%rax
jne    11ac <transpec_diffpoint+0x9c>
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x28(%rbp),%rcx
add    -0x8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
addsd  -0x18(%rbp),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x28(%rbp),%rcx
add    -0x8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
addsd  -0x18(%rbp),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    11ea <transpec_diffpoint+0xda>
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x28(%rbp),%rcx
add    -0x8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x30(%rbp),%rax
mov    -0x38(%rbp),%rcx
imul   -0x28(%rbp),%rcx
add    -0x8(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x40(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x40(%rbp)
jmp    11ef <transpec_diffpoint+0xdf>
mov    -0x38(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x38(%rbp)
jmp    1140 <transpec_diffpoint+0x30>
movsd  -0x40(%rbp),%xmm0
call   1030 <sqrt@plt>
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<transpec_diffpoint>:
xorpd  %xmm2,%xmm2
xorpd  %xmm1,%xmm1
test   %edx,%edx
jle    1169 <transpec_diffpoint+0x59>
movslq %edx,%rax
mov    %rsi,%r9
imul   %rcx,%r9
add    %rdi,%r9
lea    (%r8,%rdi,8),%rdi
shl    $0x3,%rcx
xorpd  %xmm1,%xmm1
xor    %edx,%edx
jmp    1158 <transpec_diffpoint+0x48>
nopl   0x0(%rax)
movsd  (%rdi),%xmm3
mulsd  %xmm3,%xmm3
addsd  %xmm3,%xmm1
add    $0x1,%rdx
add    %rcx,%rdi
cmp    %rdx,%rax
je     1169 <transpec_diffpoint+0x59>
cmp    %rdx,%rsi
jne    1140 <transpec_diffpoint+0x30>
movsd  (%r8,%r9,8),%xmm3
addsd  %xmm0,%xmm3
jmp    1144 <transpec_diffpoint+0x34>
ucomisd %xmm2,%xmm1
jb     1177 <transpec_diffpoint+0x67>
xorps  %xmm0,%xmm0
sqrtsd %xmm1,%xmm0
ret
movapd %xmm1,%xmm0
jmp    1030 <sqrt@plt>

LLVM IR (-O0):
define double @transpec_diffpoint(i64 %0, i64 %1, double %2, i32 %3, i64 %4, double* %5) {
%7 = alloca i64
%8 = alloca i64
%9 = alloca double
%10 = alloca i32
%11 = alloca i64
%12 = alloca double*
%13 = alloca i64
%14 = alloca double
store i64 %0, i64* %7
store i64 %1, i64* %8
store double %2, double* %9
store i32 %3, i32* %10
store i64 %4, i64* %11
store double* %5, double** %12
store double 0.000000e+00, double* %14
store i64 0, i64* %13
br label %15
15: ; preds = %67, %6
%16 = load i64, i64* %13
%17 = load i32, i32* %10
%18 = sext i32 %17 to i64
%19 = icmp slt i64 %16, %18
br i1 %19, label %20, label %70
20: ; preds = %15
%21 = load i64, i64* %13
%22 = load i64, i64* %8
%23 = icmp eq i64 %21, %22
br i1 %23, label %24, label %47
24: ; preds = %20
%25 = load double*, double** %12
%26 = load i64, i64* %13
%27 = load i64, i64* %11
%28 = mul nsw i64 %26, %27
%29 = load i64, i64* %7
%30 = add nsw i64 %28, %29
%31 = getelementptr inbounds double, double* %25, i64 %30
%32 = load double, double* %31
%33 = load double, double* %9
%34 = fadd double %32, %33
%35 = load double*, double** %12
%36 = load i64, i64* %13
%37 = load i64, i64* %11
%38 = mul nsw i64 %36, %37
%39 = load i64, i64* %7
%40 = add nsw i64 %38, %39
%41 = getelementptr inbounds double, double* %35, i64 %40
%42 = load double, double* %41
%43 = load double, double* %9
%44 = fadd double %42, %43
%45 = load double, double* %14
%46 = call double @llvm.fmuladd.f64(double %34, double %44, double %45)
store double %46, double* %14
br label %66
47: ; preds = %20
%48 = load double*, double** %12
%49 = load i64, i64* %13
%50 = load i64, i64* %11
%51 = mul nsw i64 %49, %50
%52 = load i64, i64* %7
%53 = add nsw i64 %51, %52
%54 = getelementptr inbounds double, double* %48, i64 %53
%55 = load double, double* %54
%56 = load double*, double** %12
%57 = load i64, i64* %13
%58 = load i64, i64* %11
%59 = mul nsw i64 %57, %58
%60 = load i64, i64* %7
%61 = add nsw i64 %59, %60
%62 = getelementptr inbounds double, double* %56, i64 %61
%63 = load double, double* %62
%64 = load double, double* %14
%65 = call double @llvm.fmuladd.f64(double %55, double %63, double %64)
store double %65, double* %14
br label %66
66: ; preds = %47, %24
br label %67
67: ; preds = %66
%68 = load i64, i64* %13
%69 = add nsw i64 %68, 1
store i64 %69, i64* %13
br label %15
70: ; preds = %15
%71 = load double, double* %14
%72 = call double @sqrt(double %71)
ret double %72
}

LLVM IR (-O2):
define double @transpec_diffpoint(i64 %0, i64 %1, double %2, i32 %3, i64 %4, double* nocapture %5) {
%7 = sext i32 %3 to i64
%8 = icmp sgt i32 %3, 0
br i1 %8, label %9, label %31
9: ; preds = %6
%10 = mul nsw i64 %1, %4
%11 = add nsw i64 %10, %0
%12 = getelementptr inbounds double, double* %5, i64 %11
br label %13
13: ; preds = %9, %27
%14 = phi double [ %28, %27 ], [ 0.000000e+00, %9 ]
%15 = phi i64 [ %29, %27 ], [ 0, %9 ]
%16 = icmp eq i64 %15, %1
br i1 %16, label %17, label %21
17: ; preds = %13
%18 = load double, double* %12
%19 = fadd double %18, %2
%20 = tail call double @llvm.fmuladd.f64(double %19, double %19, double %14)
br label %27
21: ; preds = %13
%22 = mul nsw i64 %15, %4
%23 = add nsw i64 %22, %0
%24 = getelementptr inbounds double, double* %5, i64 %23
%25 = load double, double* %24
%26 = tail call double @llvm.fmuladd.f64(double %25, double %25, double %14)
br label %27
27: ; preds = %17, %21
%28 = phi double [ %20, %17 ], [ %26, %21 ]
%29 = add nuw nsw i64 %15, 1
%30 = icmp eq i64 %29, %7
br i1 %30, label %31, label %13
31: ; preds = %27, %6
%32 = phi double [ 0.000000e+00, %6 ], [ %28, %27 ]
%33 = tail call double @sqrt(double %32)
ret double %33
}