float trncst(float x[], float y[], int iorder[], int ncity, int n[]) {
  float xx[7], yy[7], de;
  int j, ii;
  n[4] = 1 + (n[3] % ncity);
  n[5] = 1 + ((n[1] + ncity - 2) % ncity);
  n[6] = 1 + (n[2] % ncity);
  for (j = 1; j <= 6; j++) {
    ii = iorder[n[j]];
    xx[j] = x[ii];
    yy[j] = y[ii];
  }
  de = -sqrt(((xx[6]) - (xx[2])) * ((xx[6]) - (xx[2])) +
             ((yy[6]) - (yy[2])) * ((yy[6]) - (yy[2])));
  de -= sqrt(((xx[5]) - (xx[1])) * ((xx[5]) - (xx[1])) +
             ((yy[5]) - (yy[1])) * ((yy[5]) - (yy[1])));
  de -= sqrt(((xx[4]) - (xx[3])) * ((xx[4]) - (xx[3])) +
             ((yy[4]) - (yy[3])) * ((yy[4]) - (yy[3])));
  de += sqrt(((xx[3]) - (xx[1])) * ((xx[3]) - (xx[1])) +
             ((yy[3]) - (yy[1])) * ((yy[3]) - (yy[1])));
  de += sqrt(((xx[4]) - (xx[2])) * ((xx[4]) - (xx[2])) +
             ((yy[4]) - (yy[2])) * ((yy[4]) - (yy[2])));
  de += sqrt(((xx[6]) - (xx[5])) * ((xx[6]) - (xx[5])) +
             ((yy[6]) - (yy[5])) * ((yy[6]) - (yy[5])));
  return de;
}


x86 assembly (clang, -O0):
<trncst>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    0xc(%rax),%eax
cltd
idivl  -0x1c(%rbp)
add    $0x1,%edx
mov    -0x28(%rbp),%rax
mov    %edx,0x10(%rax)
mov    -0x28(%rbp),%rax
mov    0x4(%rax),%eax
add    -0x1c(%rbp),%eax
sub    $0x2,%eax
cltd
idivl  -0x1c(%rbp)
add    $0x1,%edx
mov    -0x28(%rbp),%rax
mov    %edx,0x14(%rax)
mov    -0x28(%rbp),%rax
mov    0x8(%rax),%eax
cltd
idivl  -0x1c(%rbp)
add    $0x1,%edx
mov    -0x28(%rbp),%rax
mov    %edx,0x18(%rax)
movl   $0x1,-0x78(%rbp)
cmpl   $0x6,-0x78(%rbp)
jg     11d6 <trncst+0xc6>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%rcx
movslq -0x78(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x78(%rbp),%rax
movss  %xmm0,-0x50(%rbp,%rax,4)
mov    -0x10(%rbp),%rax
movslq -0x7c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movslq -0x78(%rbp),%rax
movss  %xmm0,-0x70(%rbp,%rax,4)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    117a <trncst+0x6a>
movss  -0x38(%rbp),%xmm0
subss  -0x48(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
subss  -0x48(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
subss  -0x68(%rbp),%xmm1
movss  -0x58(%rbp),%xmm3
subss  -0x68(%rbp),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1030 <sqrt@plt>
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x3c(%rbp),%xmm0
subss  -0x4c(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
subss  -0x4c(%rbp),%xmm2
movss  -0x5c(%rbp),%xmm1
subss  -0x6c(%rbp),%xmm1
movss  -0x5c(%rbp),%xmm3
subss  -0x6c(%rbp),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x40(%rbp),%xmm0
subss  -0x44(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
subss  -0x44(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
subss  -0x64(%rbp),%xmm1
movss  -0x60(%rbp),%xmm3
subss  -0x64(%rbp),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
subsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x44(%rbp),%xmm0
subss  -0x4c(%rbp),%xmm0
movss  -0x44(%rbp),%xmm2
subss  -0x4c(%rbp),%xmm2
movss  -0x64(%rbp),%xmm1
subss  -0x6c(%rbp),%xmm1
movss  -0x64(%rbp),%xmm3
subss  -0x6c(%rbp),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x40(%rbp),%xmm0
subss  -0x48(%rbp),%xmm0
movss  -0x40(%rbp),%xmm2
subss  -0x48(%rbp),%xmm2
movss  -0x60(%rbp),%xmm1
subss  -0x68(%rbp),%xmm1
movss  -0x60(%rbp),%xmm3
subss  -0x68(%rbp),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x38(%rbp),%xmm0
subss  -0x3c(%rbp),%xmm0
movss  -0x38(%rbp),%xmm2
subss  -0x3c(%rbp),%xmm2
movss  -0x58(%rbp),%xmm1
subss  -0x5c(%rbp),%xmm1
movss  -0x58(%rbp),%xmm3
subss  -0x5c(%rbp),%xmm3
mulss  %xmm3,%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
call   1030 <sqrt@plt>
movaps %xmm0,%xmm1
movss  -0x74(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x74(%rbp)
movss  -0x74(%rbp),%xmm0
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<trncst>:
push   %r15
push   %r14
push   %rbx
sub    $0x40,%rsp
mov    %rdx,%r11
movslq 0xc(%r8),%r10
mov    %r10d,%eax
cltd
idiv   %ecx
mov    %edx,%r9d
lea    0x1(%r9),%eax
mov    %eax,0x10(%r8)
movslq 0x4(%r8),%r15
lea    (%rcx,%r15,1),%eax
add    $0xfffffffe,%eax
cltd
idiv   %ecx
mov    %edx,%r14d
lea    0x1(%r14),%eax
mov    %eax,0x14(%r8)
movslq 0x8(%r8),%rbx
mov    %ebx,%eax
cltd
idiv   %ecx
lea    0x1(%rdx),%eax
mov    %eax,0x18(%r8)
movslq (%r11,%r15,4),%rax
movss  (%rdi,%rax,4),%xmm0
movss  %xmm0,0xc(%rsp)
movss  (%rsi,%rax,4),%xmm0
movss  %xmm0,0x14(%rsp)
movslq (%r11,%rbx,4),%rax
movss  (%rdi,%rax,4),%xmm3
movss  (%rsi,%rax,4),%xmm2
movslq (%r11,%r10,4),%rax
movss  (%rdi,%rax,4),%xmm0
movss  %xmm0,(%rsp)
movss  (%rsi,%rax,4),%xmm0
movss  %xmm0,0x10(%rsp)
movslq %r9d,%rax
movslq 0x4(%r11,%rax,4),%rax
movss  (%rdi,%rax,4),%xmm0
movss  %xmm0,0x4(%rsp)
movss  (%rsi,%rax,4),%xmm0
movss  %xmm0,0x18(%rsp)
movslq %r14d,%rax
movslq 0x4(%r11,%rax,4),%rax
movss  (%rdi,%rax,4),%xmm0
movss  %xmm0,0x1c(%rsp)
movss  (%rsi,%rax,4),%xmm0
movss  %xmm0,0x8(%rsp)
movslq %edx,%rax
movslq 0x4(%r11,%rax,4),%rax
movss  (%rdi,%rax,4),%xmm0
movss  (%rsi,%rax,4),%xmm1
movss  %xmm0,0x2c(%rsp)
movss  %xmm3,0x20(%rsp)
subss  %xmm3,%xmm0
movss  %xmm1,0x28(%rsp)
movss  %xmm2,0x24(%rsp)
subss  %xmm2,%xmm1
mulss  %xmm1,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     1236 <trncst+0x116>
xorps  %xmm2,%xmm2
sqrtss %xmm0,%xmm2
jmp    123e <trncst+0x11e>
call   1030 <sqrtf@plt>
movaps %xmm0,%xmm2
xorps  0xdbb(%rip),%xmm2
movss  0x1c(%rsp),%xmm0
subss  0xc(%rsp),%xmm0
movss  0x8(%rsp),%xmm1
subss  0x14(%rsp),%xmm1
mulss  %xmm1,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm3,%xmm3
ucomisd %xmm3,%xmm0
jb     127c <trncst+0x15c>
sqrtsd %xmm0,%xmm0
jmp    128e <trncst+0x16e>
movaps %xmm2,0x30(%rsp)
call   1040 <sqrt@plt>
xorps  %xmm3,%xmm3
movaps 0x30(%rsp),%xmm2
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
subsd  %xmm0,%xmm1
xorps  %xmm2,%xmm2
cvtsd2ss %xmm1,%xmm2
movss  0x4(%rsp),%xmm0
subss  (%rsp),%xmm0
movss  0x18(%rsp),%xmm1
subss  0x10(%rsp),%xmm1
mulss  %xmm1,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
ucomisd %xmm3,%xmm0
jb     12d3 <trncst+0x1b3>
sqrtsd %xmm0,%xmm0
jmp    12e4 <trncst+0x1c4>
movss  %xmm2,0x30(%rsp)
call   1040 <sqrt@plt>
movss  0x30(%rsp),%xmm2
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
subsd  %xmm0,%xmm1
xorps  %xmm3,%xmm3
cvtsd2ss %xmm1,%xmm3
movss  (%rsp),%xmm0
subss  0xc(%rsp),%xmm0
movss  0x10(%rsp),%xmm1
subss  0x14(%rsp),%xmm1
mulss  %xmm1,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm2,%xmm2
ucomisd %xmm2,%xmm0
jb     132c <trncst+0x20c>
sqrtsd %xmm0,%xmm0
jmp    133e <trncst+0x21e>
movss  %xmm3,(%rsp)
call   1040 <sqrt@plt>
movss  (%rsp),%xmm3
xorps  %xmm2,%xmm2
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm3,%xmm3
cvtsd2ss %xmm1,%xmm3
movss  0x4(%rsp),%xmm0
subss  0x20(%rsp),%xmm0
movss  0x18(%rsp),%xmm1
subss  0x24(%rsp),%xmm1
mulss  %xmm1,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
ucomisd %xmm2,%xmm0
jb     1384 <trncst+0x264>
sqrtsd %xmm0,%xmm0
jmp    1395 <trncst+0x275>
movss  %xmm3,0x4(%rsp)
call   1040 <sqrt@plt>
movss  0x4(%rsp),%xmm3
xorps  %xmm1,%xmm1
cvtss2sd %xmm3,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm2,%xmm2
cvtsd2ss %xmm1,%xmm2
movss  0x2c(%rsp),%xmm0
subss  0x1c(%rsp),%xmm0
movss  0x28(%rsp),%xmm1
subss  0x8(%rsp),%xmm1
mulss  %xmm1,%xmm1
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     13de <trncst+0x2be>
sqrtsd %xmm0,%xmm0
jmp    13ef <trncst+0x2cf>
movss  %xmm2,0x8(%rsp)
call   1040 <sqrt@plt>
movss  0x8(%rsp),%xmm2
xorps  %xmm1,%xmm1
cvtss2sd %xmm2,%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm0,%xmm0
cvtsd2ss %xmm1,%xmm0
add    $0x40,%rsp
pop    %rbx
pop    %r14
pop    %r15
ret

LLVM IR (-O0):
define float @trncst(float* %0, float* %1, i32* %2, i32 %3, i32* %4) {
%6 = alloca float*
%7 = alloca float*
%8 = alloca i32*
%9 = alloca i32
%10 = alloca i32*
%11 = alloca [7 x float]
%12 = alloca [7 x float]
%13 = alloca float
%14 = alloca i32
%15 = alloca i32
store float* %0, float** %6
store float* %1, float** %7
store i32* %2, i32** %8
store i32 %3, i32* %9
store i32* %4, i32** %10
%16 = load i32*, i32** %10
%17 = getelementptr inbounds i32, i32* %16, i64 3
%18 = load i32, i32* %17
%19 = load i32, i32* %9
%20 = srem i32 %18, %19
%21 = add nsw i32 1, %20
%22 = load i32*, i32** %10
%23 = getelementptr inbounds i32, i32* %22, i64 4
store i32 %21, i32* %23
%24 = load i32*, i32** %10
%25 = getelementptr inbounds i32, i32* %24, i64 1
%26 = load i32, i32* %25
%27 = load i32, i32* %9
%28 = add nsw i32 %26, %27
%29 = sub nsw i32 %28, 2
%30 = load i32, i32* %9
%31 = srem i32 %29, %30
%32 = add nsw i32 1, %31
%33 = load i32*, i32** %10
%34 = getelementptr inbounds i32, i32* %33, i64 5
store i32 %32, i32* %34
%35 = load i32*, i32** %10
%36 = getelementptr inbounds i32, i32* %35, i64 2
%37 = load i32, i32* %36
%38 = load i32, i32* %9
%39 = srem i32 %37, %38
%40 = add nsw i32 1, %39
%41 = load i32*, i32** %10
%42 = getelementptr inbounds i32, i32* %41, i64 6
store i32 %40, i32* %42
store i32 1, i32* %14
br label %43
43: ; preds = %72, %5
%44 = load i32, i32* %14
%45 = icmp sle i32 %44, 6
br i1 %45, label %46, label %75
46: ; preds = %43
%47 = load i32*, i32** %8
%48 = load i32*, i32** %10
%49 = load i32, i32* %14
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds i32, i32* %48, i64 %50
%52 = load i32, i32* %51
%53 = sext i32 %52 to i64
%54 = getelementptr inbounds i32, i32* %47, i64 %53
%55 = load i32, i32* %54
store i32 %55, i32* %15
%56 = load float*, float** %6
%57 = load i32, i32* %15
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds float, float* %56, i64 %58
%60 = load float, float* %59
%61 = load i32, i32* %14
%62 = sext i32 %61 to i64
%63 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 %62
store float %60, float* %63
%64 = load float*, float** %7
%65 = load i32, i32* %15
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds float, float* %64, i64 %66
%68 = load float, float* %67
%69 = load i32, i32* %14
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 %70
store float %68, float* %71
br label %72
72: ; preds = %46
%73 = load i32, i32* %14
%74 = add nsw i32 %73, 1
store i32 %74, i32* %14
br label %43
75: ; preds = %43
%76 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 6
%77 = load float, float* %76
%78 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 2
%79 = load float, float* %78
%80 = fsub float %77, %79
%81 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 6
%82 = load float, float* %81
%83 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 2
%84 = load float, float* %83
%85 = fsub float %82, %84
%86 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 6
%87 = load float, float* %86
%88 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 2
%89 = load float, float* %88
%90 = fsub float %87, %89
%91 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 6
%92 = load float, float* %91
%93 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 2
%94 = load float, float* %93
%95 = fsub float %92, %94
%96 = fmul float %90, %95
%97 = call float @llvm.fmuladd.f32(float %80, float %85, float %96)
%98 = fpext float %97 to double
%99 = call double @sqrt(double %98)
%100 = fneg double %99
%101 = fptrunc double %100 to float
store float %101, float* %13
%102 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 5
%103 = load float, float* %102
%104 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 1
%105 = load float, float* %104
%106 = fsub float %103, %105
%107 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 5
%108 = load float, float* %107
%109 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 1
%110 = load float, float* %109
%111 = fsub float %108, %110
%112 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 5
%113 = load float, float* %112
%114 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 1
%115 = load float, float* %114
%116 = fsub float %113, %115
%117 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 5
%118 = load float, float* %117
%119 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 1
%120 = load float, float* %119
%121 = fsub float %118, %120
%122 = fmul float %116, %121
%123 = call float @llvm.fmuladd.f32(float %106, float %111, float %122)
%124 = fpext float %123 to double
%125 = call double @sqrt(double %124)
%126 = load float, float* %13
%127 = fpext float %126 to double
%128 = fsub double %127, %125
%129 = fptrunc double %128 to float
store float %129, float* %13
%130 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 4
%131 = load float, float* %130
%132 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 3
%133 = load float, float* %132
%134 = fsub float %131, %133
%135 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 4
%136 = load float, float* %135
%137 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 3
%138 = load float, float* %137
%139 = fsub float %136, %138
%140 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 4
%141 = load float, float* %140
%142 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 3
%143 = load float, float* %142
%144 = fsub float %141, %143
%145 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 4
%146 = load float, float* %145
%147 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 3
%148 = load float, float* %147
%149 = fsub float %146, %148
%150 = fmul float %144, %149
%151 = call float @llvm.fmuladd.f32(float %134, float %139, float %150)
%152 = fpext float %151 to double
%153 = call double @sqrt(double %152)
%154 = load float, float* %13
%155 = fpext float %154 to double
%156 = fsub double %155, %153
%157 = fptrunc double %156 to float
store float %157, float* %13
%158 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 3
%159 = load float, float* %158
%160 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 1
%161 = load float, float* %160
%162 = fsub float %159, %161
%163 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 3
%164 = load float, float* %163
%165 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 1
%166 = load float, float* %165
%167 = fsub float %164, %166
%168 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 3
%169 = load float, float* %168
%170 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 1
%171 = load float, float* %170
%172 = fsub float %169, %171
%173 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 3
%174 = load float, float* %173
%175 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 1
%176 = load float, float* %175
%177 = fsub float %174, %176
%178 = fmul float %172, %177
%179 = call float @llvm.fmuladd.f32(float %162, float %167, float %178)
%180 = fpext float %179 to double
%181 = call double @sqrt(double %180)
%182 = load float, float* %13
%183 = fpext float %182 to double
%184 = fadd double %183, %181
%185 = fptrunc double %184 to float
store float %185, float* %13
%186 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 4
%187 = load float, float* %186
%188 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 2
%189 = load float, float* %188
%190 = fsub float %187, %189
%191 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 4
%192 = load float, float* %191
%193 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 2
%194 = load float, float* %193
%195 = fsub float %192, %194
%196 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 4
%197 = load float, float* %196
%198 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 2
%199 = load float, float* %198
%200 = fsub float %197, %199
%201 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 4
%202 = load float, float* %201
%203 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 2
%204 = load float, float* %203
%205 = fsub float %202, %204
%206 = fmul float %200, %205
%207 = call float @llvm.fmuladd.f32(float %190, float %195, float %206)
%208 = fpext float %207 to double
%209 = call double @sqrt(double %208)
%210 = load float, float* %13
%211 = fpext float %210 to double
%212 = fadd double %211, %209
%213 = fptrunc double %212 to float
store float %213, float* %13
%214 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 6
%215 = load float, float* %214
%216 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 5
%217 = load float, float* %216
%218 = fsub float %215, %217
%219 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 6
%220 = load float, float* %219
%221 = getelementptr inbounds [7 x float], [7 x float]* %11, i64 0, i64 5
%222 = load float, float* %221
%223 = fsub float %220, %222
%224 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 6
%225 = load float, float* %224
%226 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 5
%227 = load float, float* %226
%228 = fsub float %225, %227
%229 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 6
%230 = load float, float* %229
%231 = getelementptr inbounds [7 x float], [7 x float]* %12, i64 0, i64 5
%232 = load float, float* %231
%233 = fsub float %230, %232
%234 = fmul float %228, %233
%235 = call float @llvm.fmuladd.f32(float %218, float %223, float %234)
%236 = fpext float %235 to double
%237 = call double @sqrt(double %236)
%238 = load float, float* %13
%239 = fpext float %238 to double
%240 = fadd double %239, %237
%241 = fptrunc double %240 to float
store float %241, float* %13
%242 = load float, float* %13
ret float %242
}

LLVM IR (-O2):
define float @trncst(float* nocapture %0, float* nocapture %1, i32* nocapture %2, i32 %3, i32* nocapture %4) {
%6 = getelementptr inbounds i32, i32* %4, i64 3
%7 = load i32, i32* %6
%8 = srem i32 %7, %3
%9 = add nsw i32 %8, 1
%10 = getelementptr inbounds i32, i32* %4, i64 4
store i32 %9, i32* %10
%11 = getelementptr inbounds i32, i32* %4, i64 1
%12 = load i32, i32* %11
%13 = add i32 %3, -2
%14 = add i32 %13, %12
%15 = srem i32 %14, %3
%16 = add nsw i32 %15, 1
%17 = getelementptr inbounds i32, i32* %4, i64 5
store i32 %16, i32* %17
%18 = getelementptr inbounds i32, i32* %4, i64 2
%19 = load i32, i32* %18
%20 = srem i32 %19, %3
%21 = add nsw i32 %20, 1
%22 = getelementptr inbounds i32, i32* %4, i64 6
store i32 %21, i32* %22
%23 = sext i32 %12 to i64
%24 = getelementptr inbounds i32, i32* %2, i64 %23
%25 = load i32, i32* %24
%26 = sext i32 %25 to i64
%27 = getelementptr inbounds float, float* %0, i64 %26
%28 = load float, float* %27
%29 = getelementptr inbounds float, float* %1, i64 %26
%30 = load float, float* %29
%31 = sext i32 %19 to i64
%32 = getelementptr inbounds i32, i32* %2, i64 %31
%33 = load i32, i32* %32
%34 = sext i32 %33 to i64
%35 = getelementptr inbounds float, float* %0, i64 %34
%36 = load float, float* %35
%37 = getelementptr inbounds float, float* %1, i64 %34
%38 = load float, float* %37
%39 = sext i32 %7 to i64
%40 = getelementptr inbounds i32, i32* %2, i64 %39
%41 = load i32, i32* %40
%42 = sext i32 %41 to i64
%43 = getelementptr inbounds float, float* %0, i64 %42
%44 = load float, float* %43
%45 = getelementptr inbounds float, float* %1, i64 %42
%46 = load float, float* %45
%47 = sext i32 %9 to i64
%48 = getelementptr inbounds i32, i32* %2, i64 %47
%49 = load i32, i32* %48
%50 = sext i32 %49 to i64
%51 = getelementptr inbounds float, float* %0, i64 %50
%52 = load float, float* %51
%53 = getelementptr inbounds float, float* %1, i64 %50
%54 = load float, float* %53
%55 = sext i32 %16 to i64
%56 = getelementptr inbounds i32, i32* %2, i64 %55
%57 = load i32, i32* %56
%58 = sext i32 %57 to i64
%59 = getelementptr inbounds float, float* %0, i64 %58
%60 = load float, float* %59
%61 = getelementptr inbounds float, float* %1, i64 %58
%62 = load float, float* %61
%63 = sext i32 %21 to i64
%64 = getelementptr inbounds i32, i32* %2, i64 %63
%65 = load i32, i32* %64
%66 = sext i32 %65 to i64
%67 = getelementptr inbounds float, float* %0, i64 %66
%68 = load float, float* %67
%69 = getelementptr inbounds float, float* %1, i64 %66
%70 = load float, float* %69
%71 = fsub float %68, %36
%72 = fsub float %70, %38
%73 = fmul float %72, %72
%74 = tail call float @llvm.fmuladd.f32(float %71, float %71, float %73)
%75 = tail call float @sqrtf(float %74)
%76 = fneg float %75
%77 = fsub float %60, %28
%78 = fsub float %62, %30
%79 = fmul float %78, %78
%80 = tail call float @llvm.fmuladd.f32(float %77, float %77, float %79)
%81 = fpext float %80 to double
%82 = tail call double @sqrt(double %81)
%83 = fpext float %76 to double
%84 = fsub double %83, %82
%85 = fptrunc double %84 to float
%86 = fsub float %52, %44
%87 = fsub float %54, %46
%88 = fmul float %87, %87
%89 = tail call float @llvm.fmuladd.f32(float %86, float %86, float %88)
%90 = fpext float %89 to double
%91 = tail call double @sqrt(double %90)
%92 = fpext float %85 to double
%93 = fsub double %92, %91
%94 = fptrunc double %93 to float
%95 = fsub float %44, %28
%96 = fsub float %46, %30
%97 = fmul float %96, %96
%98 = tail call float @llvm.fmuladd.f32(float %95, float %95, float %97)
%99 = fpext float %98 to double
%100 = tail call double @sqrt(double %99)
%101 = fpext float %94 to double
%102 = fadd double %100, %101
%103 = fptrunc double %102 to float
%104 = fsub float %52, %36
%105 = fsub float %54, %38
%106 = fmul float %105, %105
%107 = tail call float @llvm.fmuladd.f32(float %104, float %104, float %106)
%108 = fpext float %107 to double
%109 = tail call double @sqrt(double %108)
%110 = fpext float %103 to double
%111 = fadd double %109, %110
%112 = fptrunc double %111 to float
%113 = fsub float %68, %60
%114 = fsub float %70, %62
%115 = fmul float %114, %114
%116 = tail call float @llvm.fmuladd.f32(float %113, float %113, float %115)
%117 = fpext float %116 to double
%118 = tail call double @sqrt(double %117)
%119 = fpext float %112 to double
%120 = fadd double %118, %119
%121 = fptrunc double %120 to float
ret float %121
}