int find_winner_pe2(map, a, coords, data, point, ivars, map_winner, total_units,
                    map_dim)
float **map, **a, **data;
int ivars, total_units, point, map_winner, **coords;
{
  float d, bestf, diff, goodf, dist_a, dist_b, dist_c;
  int i, j, k, ma = ivars + 1, besti, diffi, disti;
  diff = a[map_winner][1] - data[point][ma];
  dist_b = 0.0;
  for (j = 1; j <= ivars; j++) {
    diff += data[point][j] * a[map_winner][j + 1];
    d = data[point][j] - map[map_winner][j];
    dist_b += d * d;
  }
  goodf = bestf = fabs(diff);
  besti = map_winner;
  for (i = 1; i <= total_units; i++) {
    disti = 0;
    k = 1;
    while (k <= map_dim && disti < 2) {
      disti += abs(coords[map_winner][k] - coords[i][k]);
      k++;
    }
    if (disti < 2) {
      dist_a = 0.0;
      dist_c = 0.0;
      diff = a[i][1] - data[point][ma];
      for (j = 1; j <= ivars; j++) {
        diff += data[point][j] * a[i][j + 1];
        d = map[map_winner][j] - map[i][j];
        dist_a += d * d;
        d = data[point][j] - map[i][j];
        dist_c += d * d;
      }
      diff = fabs(diff);
      if (diff < bestf && dist_b < dist_a && dist_c < dist_a) {
        bestf = diff;
        besti = i;
      }
    }
  }
  return (besti);
}


x86 assembly (clang, -O0):
<find_winner_pe2>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%eax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9d,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x10(%rbp),%rax
movslq 0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x4(%rax),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     1222 <find_winner_pe2+0x112>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq 0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq 0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    117c <find_winner_pe2+0x6c>
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0xdce(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x30(%rbp)
movss  %xmm0,-0x38(%rbp)
mov    0x10(%rbp),%eax
mov    %eax,-0x58(%rbp)
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     1490 <find_winner_pe2+0x380>
movl   $0x0,-0x60(%rbp)
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%ecx
xor    %eax,%eax
cmp    0x20(%rbp),%ecx
mov    %al,-0x61(%rbp)
jg     1286 <find_winner_pe2+0x176>
cmpl   $0x2,-0x60(%rbp)
setl   %al
mov    %al,-0x61(%rbp)
mov    -0x61(%rbp),%al
test   $0x1,%al
jne    1296 <find_winner_pe2+0x186>
jmp    12d5 <find_winner_pe2+0x1c5>
mov    -0x18(%rbp),%rax
movslq 0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%edi
mov    -0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
sub    (%rax,%rcx,4),%edi
call   1030 <abs@plt>
add    -0x60(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    126b <find_winner_pe2+0x15b>
cmpl   $0x2,-0x60(%rbp)
jge    147d <find_winner_pe2+0x36d>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x4(%rax),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x34(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     1412 <find_winner_pe2+0x302>
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x34(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x34(%rbp)
mov    -0x8(%rbp),%rax
movslq 0x10(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x3c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x24(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x2c(%rbp),%xmm0
movss  -0x2c(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1321 <find_winner_pe2+0x211>
movss  -0x34(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0xbde(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x34(%rbp)
movss  -0x34(%rbp),%xmm1
movss  -0x30(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1478 <find_winner_pe2+0x368>
movss  -0x40(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1478 <find_winner_pe2+0x368>
movss  -0x44(%rbp),%xmm1
movss  -0x3c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    1478 <find_winner_pe2+0x368>
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x58(%rbp)
jmp    147d <find_winner_pe2+0x36d>
jmp    1482 <find_winner_pe2+0x372>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1251 <find_winner_pe2+0x141>
mov    -0x58(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<find_winner_pe2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    0x40(%rsp),%r10d
mov    0x38(%rsp),%eax
lea    0x1(%r9),%r12d
movslq %eax,%r11
mov    %rsi,-0x10(%rsp)
mov    (%rsi,%r11,8),%rbx
movss  0x4(%rbx),%xmm1
movslq %r8d,%rbp
mov    (%rcx,%rbp,8),%r13
movslq %r12d,%rcx
movss  0x0(%r13,%rcx,4),%xmm0
subss  %xmm0,%xmm1
mov    %r12d,%r8d
mov    %r9,-0x8(%rsp)
test   %r9d,%r9d
jle    1162 <find_winner_pe2+0x62>
mov    (%rdi,%r11,8),%r15
lea    -0x1(%r8),%r14
cmp    $0x2,%r12d
jne    116a <find_winner_pe2+0x6a>
xorps  %xmm2,%xmm2
mov    $0x1,%ebp
jmp    11df <find_winner_pe2+0xdf>
xorps  %xmm2,%xmm2
jmp    1208 <find_winner_pe2+0x108>
mov    %r14,%r12
and    $0xfffffffffffffffe,%r12
neg    %r12
xorps  %xmm3,%xmm3
mov    $0x1,%ecx
nopl   0x0(%rax)
movss  0x0(%r13,%rcx,4),%xmm4
movss  0x4(%r13,%rcx,4),%xmm2
movss  0x4(%rbx,%rcx,4),%xmm5
mulss  %xmm4,%xmm5
addss  %xmm1,%xmm5
subss  (%r15,%rcx,4),%xmm4
mulss  %xmm4,%xmm4
addss  %xmm3,%xmm4
lea    0x2(%rcx),%rbp
movss  0x8(%rbx,%rcx,4),%xmm1
mulss  %xmm2,%xmm1
addss  %xmm5,%xmm1
subss  0x4(%r15,%rcx,4),%xmm2
mulss  %xmm2,%xmm2
addss  %xmm4,%xmm2
lea    (%r12,%rcx,1),%rsi
add    $0x2,%rsi
mov    %rbp,%rcx
movaps %xmm2,%xmm3
cmp    $0x1,%rsi
jne    1180 <find_winner_pe2+0x80>
test   $0x1,%r14b
je     1208 <find_winner_pe2+0x108>
movss  0x0(%r13,%rbp,4),%xmm3
movss  0x4(%rbx,%rbp,4),%xmm4
mulss  %xmm3,%xmm4
addss  %xmm4,%xmm1
subss  (%r15,%rbp,4),%xmm3
mulss  %xmm3,%xmm3
addss  %xmm3,%xmm2
test   %r10d,%r10d
jle    1341 <find_winner_pe2+0x241>
andps  0xde8(%rip),%xmm1
movslq 0x48(%rsp),%r12
add    $0x1,%r10d
add    $0xffffffffffffffff,%r8
mov    $0x1,%r15d
movaps 0xdce(%rip),%xmm3
jmp    1254 <find_winner_pe2+0x154>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmovne %r15d,%eax
movaps %xmm4,%xmm1
add    $0x1,%r15
cmp    %r10,%r15
je     1341 <find_winner_pe2+0x241>
cmpl   $0x0,0x48(%rsp)
jle    1298 <find_winner_pe2+0x198>
mov    (%rdx,%r11,8),%r14
mov    (%rdx,%r15,8),%rbx
xor    %esi,%esi
mov    $0x1,%ebp
nopw   0x0(%rax,%rax,1)
mov    %esi,%ecx
mov    (%r14,%rbp,4),%r9d
sub    (%rbx,%rbp,4),%r9d
mov    %r9d,%esi
neg    %esi
cmovs  %r9d,%esi
add    %ecx,%esi
cmp    %r12,%rbp
jge    1293 <find_winner_pe2+0x193>
add    $0x1,%rbp
cmp    $0x2,%esi
jb     1270 <find_winner_pe2+0x170>
cmp    $0x1,%esi
ja     1247 <find_winner_pe2+0x147>
mov    -0x10(%rsp),%rcx
mov    (%rcx,%r15,8),%rcx
movss  0x4(%rcx),%xmm4
subss  %xmm0,%xmm4
cmpl   $0x0,-0x8(%rsp)
jle    1310 <find_winner_pe2+0x210>
mov    (%rdi,%r11,8),%rbp
mov    (%rdi,%r15,8),%rbx
xorps  %xmm7,%xmm7
xor    %r14d,%r14d
nop
movaps %xmm7,%xmm6
movss  0x4(%r13,%r14,4),%xmm7
movss  0x8(%rcx,%r14,4),%xmm5
mulss  %xmm7,%xmm5
addss  %xmm5,%xmm4
movss  0x4(%rbp,%r14,4),%xmm5
unpcklps %xmm7,%xmm5
movss  0x4(%rbx,%r14,4),%xmm7
shufps $0x0,%xmm7,%xmm7
subps  %xmm7,%xmm5
mulps  %xmm5,%xmm5
movaps %xmm5,%xmm7
addps  %xmm6,%xmm7
add    $0x1,%r14
cmp    %r14,%r8
jne    12c0 <find_winner_pe2+0x1c0>
addps  %xmm6,%xmm5
jmp    1313 <find_winner_pe2+0x213>
nopl   0x0(%rax,%rax,1)
xorps  %xmm5,%xmm5
andps  %xmm3,%xmm4
ucomiss %xmm4,%xmm1
seta   %cl
ucomiss %xmm2,%xmm5
seta   %bl
and    %cl,%bl
movaps %xmm5,%xmm6
shufps $0x55,%xmm5,%xmm6
ucomiss %xmm6,%xmm5
seta   %cl
test   %cl,%bl
jne    1240 <find_winner_pe2+0x140>
movaps %xmm1,%xmm4
jmp    1240 <find_winner_pe2+0x140>
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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