#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
double fabs(float const);
float sqr(float const);
void compute_cross_distances_alt_nonpacked(int distance_type, int d, int na,
                                           int nb, const float *a, int lda,
                                           const float *b, int ldb,
                                           float *dist2, int ldd) {
  int i, j, k;
  float av, bv, den;
  float *dline;
  const float *bline, *aline;
  double sum;
  for (j = 0; j < nb; j++) {
    dline = dist2 + j * ldd;
    bline = b + ldb * j;
    aline = a;
    for (i = 0; i < na; i++) {
      sum = 0;
      if (distance_type == 1) {
        for (k = 0; k < d; k++) {
          sum += fabs(aline[k] - bline[k]);
        }
      } else if (distance_type == 2) {
        for (k = 0; k < d; k++) {
          sum += sqr(aline[k] - bline[k]);
        }
      } else if (distance_type == 3) {
        for (k = 0; k < d; k++) {
          av = aline[k];
          bv = bline[k];
          sum += av + bv == 0 ? 0 : sqr(av - bv) / (av + bv);
        }
      } else if (distance_type == 4) {
        for (k = 0; k < d; k++) {
          av = aline[k];
          bv = bline[k];
          den = fabs(av + bv);
          sum += den == 0 ? 0 : sqr(av - bv) / den;
        }
      }
      dline[i] = sum;
      aline += lda;
    }
  }
}


x86 assembly (clang, -O0):
<compute_cross_distances_alt_nonpacked>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8,-0x18(%rbp)
mov    %r9d,-0x1c(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1431 <compute_cross_distances_alt_nonpacked+0x311>
mov    0x20(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   0x28(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    0x10(%rbp),%rax
mov    0x18(%rbp),%ecx
imul   -0x24(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
mov    -0x18(%rbp),%rax
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    141e <compute_cross_distances_alt_nonpacked+0x2fe>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
cmpl   $0x1,-0x4(%rbp)
jne    120b <compute_cross_distances_alt_nonpacked+0xeb>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1206 <compute_cross_distances_alt_nonpacked+0xe6>
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
call   1030 <fabs@plt>
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    11c3 <compute_cross_distances_alt_nonpacked+0xa3>
jmp    13e5 <compute_cross_distances_alt_nonpacked+0x2c5>
cmpl   $0x2,-0x4(%rbp)
jne    1268 <compute_cross_distances_alt_nonpacked+0x148>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1263 <compute_cross_distances_alt_nonpacked+0x143>
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
call   1040 <sqr@plt>
cvtss2sd %xmm0,%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    121c <compute_cross_distances_alt_nonpacked+0xfc>
jmp    13e0 <compute_cross_distances_alt_nonpacked+0x2c0>
cmpl   $0x3,-0x4(%rbp)
jne    131a <compute_cross_distances_alt_nonpacked+0x1fa>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1315 <compute_cross_distances_alt_nonpacked+0x1f5>
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x2c(%rbp),%xmm0
addss  -0x30(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    12d2 <compute_cross_distances_alt_nonpacked+0x1b2>
jp     12d2 <compute_cross_distances_alt_nonpacked+0x1b2>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x5c(%rbp)
jmp    12f4 <compute_cross_distances_alt_nonpacked+0x1d4>
movss  -0x2c(%rbp),%xmm0
subss  -0x30(%rbp),%xmm0
call   1040 <sqr@plt>
movss  -0x2c(%rbp),%xmm1
addss  -0x30(%rbp),%xmm1
divss  %xmm1,%xmm0
movss  %xmm0,-0x5c(%rbp)
movss  -0x5c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1279 <compute_cross_distances_alt_nonpacked+0x159>
jmp    13db <compute_cross_distances_alt_nonpacked+0x2bb>
cmpl   $0x4,-0x4(%rbp)
jne    13d6 <compute_cross_distances_alt_nonpacked+0x2b6>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    13d1 <compute_cross_distances_alt_nonpacked+0x2b1>
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x2c(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x30(%rbp)
movss  -0x2c(%rbp),%xmm0
addss  -0x30(%rbp),%xmm0
call   1030 <fabs@plt>
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1397 <compute_cross_distances_alt_nonpacked+0x277>
jp     1397 <compute_cross_distances_alt_nonpacked+0x277>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x60(%rbp)
jmp    13b0 <compute_cross_distances_alt_nonpacked+0x290>
movss  -0x2c(%rbp),%xmm0
subss  -0x30(%rbp),%xmm0
call   1040 <sqr@plt>
divss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
movss  -0x60(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
addsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x58(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    132b <compute_cross_distances_alt_nonpacked+0x20b>
jmp    13d6 <compute_cross_distances_alt_nonpacked+0x2b6>
jmp    13db <compute_cross_distances_alt_nonpacked+0x2bb>
jmp    13e0 <compute_cross_distances_alt_nonpacked+0x2c0>
jmp    13e5 <compute_cross_distances_alt_nonpacked+0x2c5>
movsd  -0x58(%rbp),%xmm0
cvtsd2ss %xmm0,%xmm0
mov    -0x40(%rbp),%rax
movslq -0x20(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x1c(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    119e <compute_cross_distances_alt_nonpacked+0x7e>
jmp    1423 <compute_cross_distances_alt_nonpacked+0x303>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1151 <compute_cross_distances_alt_nonpacked+0x31>
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<compute_cross_distances_alt_nonpacked>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %r8,0x38(%rsp)
mov    %edx,0x14(%rsp)
mov    %esi,0xc(%rsp)
test   %ecx,%ecx
jle    14d0 <compute_cross_distances_alt_nonpacked+0x3b0>
mov    0xc0(%rsp),%rbx
movslq %r9d,%rax
movslq 0xd8(%rsp),%rdx
mov    %rdx,0x30(%rsp)
movslq 0xc8(%rsp),%rdx
mov    %ecx,%ecx
mov    %rcx,0x40(%rsp)
mov    0x14(%rsp),%ecx
mov    %rcx,0x60(%rsp)
mov    0xc(%rsp),%r14d
lea    -0x1(%r14),%rcx
mov    %rcx,0x58(%rsp)
mov    %r14d,%ecx
and    $0x3,%ecx
mov    %rcx,0x28(%rsp)
mov    %r14d,%ecx
and    $0xfffffffc,%ecx
mov    %rcx,0x50(%rsp)
shl    $0x2,%rdx
mov    %rdx,0x48(%rsp)
shl    $0x2,%rax
mov    %rax,0x68(%rsp)
xor    %eax,%eax
mov    %rax,0x18(%rsp)
add    $0xffffffff,%edi
mov    %rdi,0x70(%rsp)
jmp    11e1 <compute_cross_distances_alt_nonpacked+0xc1>
nopl   (%rax)
mov    0x18(%rsp),%rcx
add    $0x1,%rcx
add    0x48(%rsp),%rbx
mov    %rcx,%rax
mov    %rcx,0x18(%rsp)
cmp    0x40(%rsp),%rcx
je     14d0 <compute_cross_distances_alt_nonpacked+0x3b0>
cmpl   $0x0,0x14(%rsp)
jle    11c0 <compute_cross_distances_alt_nonpacked+0xa0>
mov    0x18(%rsp),%rax
imul   0x30(%rsp),%rax
mov    0xd0(%rsp),%rcx
lea    (%rcx,%rax,4),%rax
mov    %rax,0x78(%rsp)
mov    0x38(%rsp),%r15
xor    %eax,%eax
jmp    1245 <compute_cross_distances_alt_nonpacked+0x125>
nopl   (%rax)
xorps  %xmm0,%xmm0
cvtsd2ss %xmm3,%xmm0
mov    0x78(%rsp),%rax
mov    0x80(%rsp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    %rcx,%rax
add    $0x1,%rax
add    0x68(%rsp),%r15
cmp    0x60(%rsp),%rax
mov    0x70(%rsp),%rdi
je     11c0 <compute_cross_distances_alt_nonpacked+0xa0>
mov    %rax,0x80(%rsp)
xorpd  %xmm3,%xmm3
cmp    $0x3,%edi
ja     1210 <compute_cross_distances_alt_nonpacked+0xf0>
lea    0xda3(%rip),%rcx
movslq (%rcx,%rdi,4),%rax
add    %rcx,%rax
jmp    *%rax
cmpl   $0x0,0xc(%rsp)
jle    1210 <compute_cross_distances_alt_nonpacked+0xf0>
cmpq   $0x3,0x58(%rsp)
jae    13ef <compute_cross_distances_alt_nonpacked+0x2cf>
xorpd  %xmm3,%xmm3
xor    %r12d,%r12d
jmp    147e <compute_cross_distances_alt_nonpacked+0x35e>
cs nopw 0x0(%rax,%rax,1)
nop
cmpl   $0x0,0xc(%rsp)
jle    1210 <compute_cross_distances_alt_nonpacked+0xf0>
xorpd  %xmm3,%xmm3
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  %xmm3,(%rsp)
movss  (%r15,%rbp,4),%xmm0
subss  (%rbx,%rbp,4),%xmm0
call   1040 <sqr@plt>
movsd  (%rsp),%xmm3
cvtss2sd %xmm0,%xmm0
addsd  %xmm0,%xmm3
add    $0x1,%rbp
cmp    %rbp,%r14
jne    12b0 <compute_cross_distances_alt_nonpacked+0x190>
jmp    1210 <compute_cross_distances_alt_nonpacked+0xf0>
cmpl   $0x0,0xc(%rsp)
jle    1210 <compute_cross_distances_alt_nonpacked+0xf0>
xorpd  %xmm3,%xmm3
xor    %ebp,%ebp
jmp    1318 <compute_cross_distances_alt_nonpacked+0x1f8>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
addsd  %xmm0,%xmm3
add    $0x1,%rbp
cmp    %rbp,%r14
je     1210 <compute_cross_distances_alt_nonpacked+0xf0>
movss  (%r15,%rbp,4),%xmm0
movss  (%rbx,%rbp,4),%xmm2
movaps %xmm0,%xmm4
addss  %xmm2,%xmm4
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm4
jne    1334 <compute_cross_distances_alt_nonpacked+0x214>
jnp    1300 <compute_cross_distances_alt_nonpacked+0x1e0>
subss  %xmm2,%xmm0
movsd  %xmm3,(%rsp)
movss  %xmm4,0x10(%rsp)
call   1040 <sqr@plt>
movsd  (%rsp),%xmm3
movaps %xmm0,%xmm1
divss  0x10(%rsp),%xmm1
jmp    1300 <compute_cross_distances_alt_nonpacked+0x1e0>
nopl   0x0(%rax,%rax,1)
cmpl   $0x0,0xc(%rsp)
jle    1210 <compute_cross_distances_alt_nonpacked+0xf0>
xorpd  %xmm3,%xmm3
xor    %ebp,%ebp
jmp    139a <compute_cross_distances_alt_nonpacked+0x27a>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cvtss2sd %xmm0,%xmm0
movsd  (%rsp),%xmm3
addsd  %xmm0,%xmm3
add    $0x1,%rbp
cmp    %rbp,%r14
je     1210 <compute_cross_distances_alt_nonpacked+0xf0>
movsd  %xmm3,(%rsp)
movss  (%r15,%rbp,4),%xmm0
movss  (%rbx,%rbp,4),%xmm1
movss  %xmm0,0x10(%rsp)
movss  %xmm1,0x24(%rsp)
addss  %xmm1,%xmm0
call   1030 <fabs@plt>
xorps  %xmm1,%xmm1
cvtsd2ss %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm1
jne    13d0 <compute_cross_distances_alt_nonpacked+0x2b0>
jnp    1380 <compute_cross_distances_alt_nonpacked+0x260>
movss  0x10(%rsp),%xmm0
subss  0x24(%rsp),%xmm0
movss  %xmm1,0x10(%rsp)
call   1040 <sqr@plt>
divss  0x10(%rsp),%xmm0
jmp    1380 <compute_cross_distances_alt_nonpacked+0x260>
xorpd  %xmm3,%xmm3
xor    %r12d,%r12d
mov    0x50(%rsp),%rbp
nopl   0x0(%rax,%rax,1)
movsd  %xmm3,(%rsp)
movss  (%r15,%r12,4),%xmm0
subss  (%rbx,%r12,4),%xmm0
call   1030 <fabs@plt>
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
movss  0x4(%r15,%r12,4),%xmm0
subss  0x4(%rbx,%r12,4),%xmm0
call   1030 <fabs@plt>
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
movss  0x8(%r15,%r12,4),%xmm0
subss  0x8(%rbx,%r12,4),%xmm0
call   1030 <fabs@plt>
addsd  (%rsp),%xmm0
movsd  %xmm0,(%rsp)
movss  0xc(%r15,%r12,4),%xmm0
subss  0xc(%rbx,%r12,4),%xmm0
call   1030 <fabs@plt>
movaps %xmm0,%xmm3
addsd  (%rsp),%xmm3
add    $0x4,%r12
cmp    %r12,%rbp
jne    1400 <compute_cross_distances_alt_nonpacked+0x2e0>
cmpq   $0x0,0x28(%rsp)
je     1210 <compute_cross_distances_alt_nonpacked+0xf0>
lea    (%rbx,%r12,4),%r13
lea    (%r15,%r12,4),%r12
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  %xmm3,(%rsp)
movss  (%r12,%rbp,4),%xmm0
subss  0x0(%r13,%rbp,4),%xmm0
call   1030 <fabs@plt>
movsd  (%rsp),%xmm3
addsd  %xmm0,%xmm3
add    $0x1,%rbp
cmp    %rbp,0x28(%rsp)
jne    14a0 <compute_cross_distances_alt_nonpacked+0x380>
jmp    1210 <compute_cross_distances_alt_nonpacked+0xf0>
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

LLVM IR (-O2):
define void @compute_cross_distances_alt_nonpacked(i32 %0, i32 %1, i32 %2, i32 %3, float* nocapture %4, i32 %5, float* nocapture %6, i32 %7, float* nocapture writeonly %8, i32 %9) {
%11 = icmp sgt i32 %3, 0
br i1 %11, label %12, label %162
12: ; preds = %10
%13 = icmp sgt i32 %2, 0
%14 = icmp sgt i32 %1, 0
%15 = sext i32 %5 to i64
%16 = sext i32 %9 to i64
%17 = sext i32 %7 to i64
%18 = zext i32 %3 to i64
%19 = zext i32 %2 to i64
%20 = zext i32 %1 to i64
%21 = zext i32 %1 to i64
%22 = zext i32 %1 to i64
%23 = zext i32 %1 to i64
%24 = add nsw i64 %23, -1
%25 = and i64 %23, 3
%26 = icmp ult i64 %24, 3
%27 = and i64 %23, 4294967292
%28 = icmp eq i64 %25, 0
br label %29
29: ; preds = %12, %159
%30 = phi i64 [ 0, %12 ], [ %160, %159 ]
%31 = mul nsw i64 %30, %16
%32 = getelementptr inbounds float, float* %8, i64 %31
%33 = mul nsw i64 %30, %17
%34 = getelementptr inbounds float, float* %6, i64 %33
br i1 %13, label %35, label %159
35: ; preds = %29, %152
%36 = phi i64 [ %157, %152 ], [ 0, %29 ]
%37 = phi float* [ %156, %152 ], [ %4, %29 ]
switch i32 %0, label %152 [
i32 1, label %41
i32 2, label %40
i32 3, label %39
i32 4, label %38
]
38: ; preds = %35
br i1 %14, label %113, label %152
39: ; preds = %35
br i1 %14, label %94, label %152
40: ; preds = %35
br i1 %14, label %81, label %152
41: ; preds = %35
br i1 %14, label %42, label %152
42: ; preds = %41
br i1 %26, label %134, label %43
43: ; preds = %42, %43
%44 = phi i64 [ %78, %43 ], [ 0, %42 ]
%45 = phi double [ %77, %43 ], [ 0.000000e+00, %42 ]
%46 = phi i64 [ %79, %43 ], [ 0, %42 ]
%47 = getelementptr inbounds float, float* %37, i64 %44
%48 = load float, float* %47
%49 = getelementptr inbounds float, float* %34, i64 %44
%50 = load float, float* %49
%51 = fsub float %48, %50
%52 = tail call double @fabs(float %51)
%53 = fadd double %45, %52
%54 = or i64 %44, 1
%55 = getelementptr inbounds float, float* %37, i64 %54
%56 = load float, float* %55
%57 = getelementptr inbounds float, float* %34, i64 %54
%58 = load float, float* %57
%59 = fsub float %56, %58
%60 = tail call double @fabs(float %59)
%61 = fadd double %53, %60
%62 = or i64 %44, 2
%63 = getelementptr inbounds float, float* %37, i64 %62
%64 = load float, float* %63
%65 = getelementptr inbounds float, float* %34, i64 %62
%66 = load float, float* %65
%67 = fsub float %64, %66
%68 = tail call double @fabs(float %67)
%69 = fadd double %61, %68
%70 = or i64 %44, 3
%71 = getelementptr inbounds float, float* %37, i64 %70
%72 = load float, float* %71
%73 = getelementptr inbounds float, float* %34, i64 %70
%74 = load float, float* %73
%75 = fsub float %72, %74
%76 = tail call double @fabs(float %75)
%77 = fadd double %69, %76
%78 = add nuw nsw i64 %44, 4
%79 = add nuw i64 %46, 4
%80 = icmp eq i64 %79, %27
br i1 %80, label %134, label %43
81: ; preds = %40, %81
%82 = phi i64 [ %92, %81 ], [ 0, %40 ]
%83 = phi double [ %91, %81 ], [ 0.000000e+00, %40 ]
%84 = getelementptr inbounds float, float* %37, i64 %82
%85 = load float, float* %84
%86 = getelementptr inbounds float, float* %34, i64 %82
%87 = load float, float* %86
%88 = fsub float %85, %87
%89 = tail call float @sqr(float %88)
%90 = fpext float %89 to double
%91 = fadd double %83, %90
%92 = add nuw nsw i64 %82, 1
%93 = icmp eq i64 %92, %22
br i1 %93, label %152, label %81
94: ; preds = %39, %107
%95 = phi i64 [ %111, %107 ], [ 0, %39 ]
%96 = phi double [ %110, %107 ], [ 0.000000e+00, %39 ]
%97 = getelementptr inbounds float, float* %37, i64 %95
%98 = load float, float* %97
%99 = getelementptr inbounds float, float* %34, i64 %95
%100 = load float, float* %99
%101 = fadd float %98, %100
%102 = fcmp oeq float %101, 0.000000e+00
br i1 %102, label %107, label %103
103: ; preds = %94
%104 = fsub float %98, %100
%105 = tail call float @sqr(float %104)
%106 = fdiv float %105, %101
br label %107
107: ; preds = %94, %103
%108 = phi float [ %106, %103 ], [ 0.000000e+00, %94 ]
%109 = fpext float %108 to double
%110 = fadd double %96, %109
%111 = add nuw nsw i64 %95, 1
%112 = icmp eq i64 %111, %21
br i1 %112, label %152, label %94
113: ; preds = %38, %128
%114 = phi i64 [ %132, %128 ], [ 0, %38 ]
%115 = phi double [ %131, %128 ], [ 0.000000e+00, %38 ]
%116 = getelementptr inbounds float, float* %37, i64 %114
%117 = load float, float* %116
%118 = getelementptr inbounds float, float* %34, i64 %114
%119 = load float, float* %118
%120 = fadd float %117, %119
%121 = tail call double @fabs(float %120)
%122 = fptrunc double %121 to float
%123 = fcmp oeq float %122, 0.000000e+00
br i1 %123, label %128, label %124
124: ; preds = %113
%125 = fsub float %117, %119
%126 = tail call float @sqr(float %125)
%127 = fdiv float %126, %122
br label %128
128: ; preds = %113, %124
%129 = phi float [ %127, %124 ], [ 0.000000e+00, %113 ]
%130 = fpext float %129 to double
%131 = fadd double %115, %130
%132 = add nuw nsw i64 %114, 1
%133 = icmp eq i64 %132, %20
br i1 %133, label %152, label %113
134: ; preds = %43, %42
%135 = phi double [ undef, %42 ], [ %77, %43 ]
%136 = phi i64 [ 0, %42 ], [ %78, %43 ]
%137 = phi double [ 0.000000e+00, %42 ], [ %77, %43 ]
br i1 %28, label %152, label %138
138: ; preds = %134, %138
%139 = phi i64 [ %149, %138 ], [ %136, %134 ]
%140 = phi double [ %148, %138 ], [ %137, %134 ]
%141 = phi i64 [ %150, %138 ], [ 0, %134 ]
%142 = getelementptr inbounds float, float* %37, i64 %139
%143 = load float, float* %142
%144 = getelementptr inbounds float, float* %34, i64 %139
%145 = load float, float* %144
%146 = fsub float %143, %145
%147 = tail call double @fabs(float %146)
%148 = fadd double %140, %147
%149 = add nuw nsw i64 %139, 1
%150 = add i64 %141, 1
%151 = icmp eq i64 %150, %25
br i1 %151, label %152, label %138
152: ; preds = %128, %107, %81, %134, %138, %38, %39, %40, %41, %35
%153 = phi double [ 0.000000e+00, %35 ], [ 0.000000e+00, %41 ], [ 0.000000e+00, %40 ], [ 0.000000e+00, %39 ], [ 0.000000e+00, %38 ], [ %135, %134 ], [ %148, %138 ], [ %91, %81 ], [ %110, %107 ], [ %131, %128 ]
%154 = fptrunc double %153 to float
%155 = getelementptr inbounds float, float* %32, i64 %36
store float %154, float* %155
%156 = getelementptr inbounds float, float* %37, i64 %15
%157 = add nuw nsw i64 %36, 1
%158 = icmp eq i64 %157, %19
br i1 %158, label %159, label %35
159: ; preds = %152, %29
%160 = add nuw nsw i64 %30, 1
%161 = icmp eq i64 %160, %18
br i1 %161, label %162, label %29
162: ; preds = %159, %10
ret void
}