int greedy(float *A, int nvec, int ndim, int N, float **codebook, float t,
           unsigned char *P, float *weight) {
  int iv, in, jn, imax, nsplit, *index2, k, i, retgla, kn;
  float *totalw, *d, **buf, *variance;
  buf = fmatrix(N, ndim);
  d = (float *)calloc(ndim, sizeof(float));
  variance = (float *)calloc(N, sizeof(float));
  totalw = (float *)calloc(N, sizeof(float));
  index2 = (int *)calloc(N, sizeof(int));
  for (k = 0; k < ndim; k++)
    codebook[0][k] = 0.0;
  totalw[0] = 0;
  i = 0;
  for (iv = 0; iv < nvec; iv++) {
    P[iv] = 0;
    totalw[0] += weight[iv];
    for (k = 0; k < ndim; k++)
      codebook[0][k] += weight[iv] * A[i++];
  }
  for (k = 0; k < ndim; k++)
    codebook[0][k] /= totalw[0];
  in = 1;
  while (in < N) {
    for (jn = 0; jn < in; jn++) {
      variance[jn] = 0;
      totalw[jn] = 0;
      for (k = 0; k < ndim; k++)
        buf[jn][k] = 0.0;
    }
    i = 0;
    for (iv = 0; iv < nvec; iv++) {
      for (k = 0; k < ndim; k++)
        d[k] = codebook[P[iv]][k] - A[i++];
      for (k = 0; k < ndim; k++) {
        buf[P[iv]][k] += weight[iv] * ((d[k]) * (d[k]));
        variance[P[iv]] += buf[P[iv]][k];
      }
      totalw[P[iv]] += weight[iv];
    }
    for (jn = 0; jn < in; jn++) {
      for (k = 0; k < ndim; k++)
        buf[jn][k] = sqrt(buf[jn][k] / totalw[jn]);
    }
    piksrt(in, variance, index2);
    nsplit = in / 2 + 1;
    if ((nsplit + in) > N)
      nsplit = N - in;
    for (jn = 0; jn < nsplit; jn++) {
      imax = index2[jn];
      for (k = 0; k < ndim; k++)
        codebook[in + jn][k] = codebook[imax][k] - buf[imax][k];
      for (k = 0; k < ndim; k++)
        codebook[imax][k] = codebook[imax][k] + buf[imax][k];
    }
    in = in + nsplit;
    retgla = gla(A, nvec, ndim, in, codebook, t, P, weight);
    if (retgla) {
      for (jn = 0; jn < in - 1; jn++) {
        for (kn = jn + 1; kn < in; kn++) {
          if (distance2(codebook[jn], codebook[kn], ndim) == 0) {
            for (i = kn; i < in - 1; i++)
              for (k = 0; k < ndim; k++)
                codebook[i][k] = codebook[i + 1][k];
            in--;
          }
        }
      }
      break;
    }
  }
  free_fmatrix(buf, N);
  free(d);
  free(index2);
  free(variance);
  free(totalw);
  return in;
}


x86 assembly (clang, -O0):
<greedy>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8,-0x20(%rbp)
movss  %xmm0,-0x24(%rbp)
mov    %r9,-0x30(%rbp)
mov    -0x14(%rbp),%edi
mov    -0x10(%rbp),%esi
mov    $0x0,%al
call   1080 <fmatrix@plt>
cltq
mov    %rax,-0x78(%rbp)
movslq -0x10(%rbp),%rdi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0x70(%rbp)
movslq -0x14(%rbp),%rdi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0x80(%rbp)
movslq -0x14(%rbp),%rdi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0x68(%rbp)
movslq -0x14(%rbp),%rdi
mov    $0x4,%esi
call   1070 <calloc@plt>
mov    %rax,-0x50(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1238 <greedy+0xb8>
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    120b <greedy+0x8b>
mov    -0x68(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
movl   $0x0,-0x58(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    12f7 <greedy+0x177>
mov    -0x30(%rbp),%rax
movslq -0x34(%rbp),%rcx
movb   $0x0,(%rax,%rcx,1)
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    12e4 <greedy+0x164>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x58(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1289 <greedy+0x109>
jmp    12e9 <greedy+0x169>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1251 <greedy+0xd1>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1339 <greedy+0x1b9>
mov    -0x68(%rbp),%rax
movss  (%rax),%xmm1
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    12fe <greedy+0x17e>
movl   $0x1,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1832 <greedy+0x6b2>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    13cb <greedy+0x24b>
mov    -0x80(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    13b8 <greedy+0x238>
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1386 <greedy+0x206>
jmp    13bd <greedy+0x23d>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1353 <greedy+0x1d3>
movl   $0x0,-0x58(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1525 <greedy+0x3a5>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1447 <greedy+0x2c7>
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x8(%rbp),%rax
mov    -0x58(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x58(%rbp)
movslq %ecx,%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    13ec <greedy+0x26c>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    14f0 <greedy+0x370>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x70(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    -0x70(%rbp),%rax
movslq -0x54(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm2
mov    -0x78(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x78(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x80(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    144e <greedy+0x2ce>
mov    0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
mov    -0x30(%rbp),%rcx
movslq -0x34(%rbp),%rdx
movzbl (%rcx,%rdx,1),%ecx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13d9 <greedy+0x259>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    15b0 <greedy+0x430>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    159d <greedy+0x41d>
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x3c(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
call   1090 <sqrt@plt>
cvtsd2ss %xmm0,%xmm0
mov    -0x78(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    153f <greedy+0x3bf>
jmp    15a2 <greedy+0x422>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    152c <greedy+0x3ac>
mov    -0x38(%rbp),%edi
mov    -0x80(%rbp),%rsi
mov    -0x50(%rbp),%rdx
mov    $0x0,%al
call   1060 <piksrt@plt>
mov    -0x38(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
add    -0x38(%rbp),%eax
cmp    -0x14(%rbp),%eax
jle    15eb <greedy+0x46b>
mov    -0x14(%rbp),%eax
sub    -0x38(%rbp),%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    16e4 <greedy+0x564>
mov    -0x50(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x40(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1671 <greedy+0x4f1>
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
subss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
add    -0x3c(%rbp),%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1613 <greedy+0x493>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    16d1 <greedy+0x551>
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x78(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1678 <greedy+0x4f8>
jmp    16d6 <greedy+0x556>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    15f2 <greedy+0x472>
mov    -0x38(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%rdi
mov    -0xc(%rbp),%esi
mov    -0x10(%rbp),%edx
mov    -0x38(%rbp),%ecx
mov    -0x20(%rbp),%r8
movss  -0x24(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
mov    -0x30(%rbp),%r9
mov    0x10(%rbp),%rax
mov    %rax,(%rsp)
mov    $0x1,%al
call   10a0 <gla@plt>
mov    %eax,-0x5c(%rbp)
cmpl   $0x0,-0x5c(%rbp)
je     182d <greedy+0x6ad>
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1828 <greedy+0x6a8>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
mov    -0x60(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1815 <greedy+0x695>
mov    -0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x20(%rbp),%rax
movslq -0x60(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0x10(%rbp),%edx
mov    $0x0,%al
call   1040 <distance2@plt>
cmp    $0x0,%eax
jne    1802 <greedy+0x682>
mov    -0x60(%rbp),%eax
mov    %eax,-0x58(%rbp)
mov    -0x58(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    17f9 <greedy+0x679>
movl   $0x0,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    17e6 <greedy+0x666>
mov    -0x20(%rbp),%rax
mov    -0x58(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    179d <greedy+0x61d>
jmp    17eb <greedy+0x66b>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1785 <greedy+0x605>
mov    -0x38(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x38(%rbp)
jmp    1807 <greedy+0x687>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1748 <greedy+0x5c8>
jmp    181a <greedy+0x69a>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    172e <greedy+0x5ae>
jmp    1832 <greedy+0x6b2>
jmp    1340 <greedy+0x1c0>
mov    -0x78(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    $0x0,%al
call   1050 <free_fmatrix@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<greedy>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
mov    %r9,0x68(%rsp)
movss  %xmm0,0x70(%rsp)
mov    %r8,%rbp
mov    %ecx,%r15d
mov    %edx,%ebx
mov    %esi,%r14d
mov    %rdi,0x38(%rsp)
mov    %ecx,%edi
mov    %edx,%esi
xor    %eax,%eax
call   10a0 <fmatrix@plt>
mov    %eax,0x78(%rsp)
movslq %ebx,%rdi
mov    %rdi,0x28(%rsp)
mov    $0x4,%esi
call   1080 <calloc@plt>
mov    %rax,0x88(%rsp)
mov    %r15d,0x64(%rsp)
movslq %r15d,%r13
mov    $0x4,%esi
mov    %r13,%rdi
call   1080 <calloc@plt>
mov    %rax,%r12
mov    $0x4,%esi
mov    %r13,%rdi
call   1080 <calloc@plt>
mov    %rax,0x30(%rsp)
mov    $0x4,%esi
mov    %r13,%rdi
call   1080 <calloc@plt>
mov    %rax,0xa0(%rsp)
cmpl   $0x0,0x28(%rsp)
jle    123c <greedy+0xac>
mov    0x0(%rbp),%rdi
mov    %ebx,%edx
shl    $0x2,%rdx
xor    %esi,%esi
call   1050 <memset@plt>
mov    %rbp,0x10(%rsp)
mov    0x100(%rsp),%rbp
mov    %r14d,%eax
mov    %rax,0x98(%rsp)
mov    %r14d,0x94(%rsp)
test   %r14d,%r14d
mov    %ebx,0xc(%rsp)
mov    %r12,0x50(%rsp)
mov    0x68(%rsp),%r9
jle    152b <greedy+0x39b>
mov    %ebx,%r11d
mov    0x38(%rsp),%rax
lea    0x4(%rax),%r15
lea    (%rax,%r11,4),%rcx
mov    %rcx,0x58(%rsp)
lea    -0x1(%r11),%r10
mov    %r10,%rdi
and    $0xfffffffffffffff8,%rdi
lea    0x1(%rdi),%rcx
mov    %rcx,0x80(%rsp)
mov    %r11,%rcx
neg    %rcx
mov    %rcx,0x28(%rsp)
add    $0x14,%rax
mov    %rax,0x48(%rsp)
xor    %ecx,%ecx
xorps  %xmm0,%xmm0
xor    %r13d,%r13d
mov    0x10(%rsp),%r8
mov    0x30(%rsp),%r14
mov    %r11,0x40(%rsp)
mov    %r15,0x20(%rsp)
mov    %r10,0x18(%rsp)
jmp    12fa <greedy+0x16a>
cs nopw 0x0(%rax,%rax,1)
mov    0xc(%rsp),%ebx
addss  %xmm1,%xmm0
add    $0x1,%rcx
cmp    0x98(%rsp),%rcx
je     150c <greedy+0x37c>
movb   $0x0,(%r9,%rcx,1)
movss  0x0(%rbp,%rcx,4),%xmm1
test   %ebx,%ebx
jle    12e4 <greedy+0x154>
mov    %ebx,%eax
movslq %r13d,%rbx
lea    0x1(%rbx),%r13
mov    (%r8),%rsi
mov    0x38(%rsp),%rdx
movss  (%rdx,%rbx,4),%xmm2
mulss  %xmm1,%xmm2
addss  (%rsi),%xmm2
movss  %xmm2,(%rsi)
cmp    $0x1,%eax
je     12e0 <greedy+0x150>
mov    $0x1,%eax
cmp    $0x8,%r10
jae    1351 <greedy+0x1c1>
mov    0xc(%rsp),%ebx
test   $0x1,%r11b
je     144a <greedy+0x2ba>
mov    %rax,%rdx
jmp    146d <greedy+0x2dd>
lea    0x0(,%rcx,4),%r8
add    %rbp,%r8
lea    0x4(%rbp,%rcx,4),%rdx
lea    0x4(%rsi),%r10
lea    (%rsi,%r11,4),%r9
lea    (%r15,%rbx,4),%r11
mov    0x58(%rsp),%rbp
lea    0x0(,%rbx,4),%r15
add    %rbp,%r15
cmp    %rdx,%r10
setb   %r12b
cmp    %r9,%r8
setb   %r14b
cmp    %r15,%r10
setb   %dl
cmp    %r9,%r11
setb   %r8b
test   %r14b,%r12b
jne    14ce <greedy+0x33e>
and    %r8b,%dl
jne    14ce <greedy+0x33e>
add    %rdi,%r13
mov    0x100(%rsp),%rbp
movss  0x0(%rbp,%rcx,4),%xmm2
shufps $0x0,%xmm2,%xmm2
mov    0x48(%rsp),%rax
lea    (%rax,%rbx,4),%rax
xor    %edx,%edx
mov    0x10(%rsp),%r8
mov    0x50(%rsp),%r12
mov    0x30(%rsp),%r14
mov    0x68(%rsp),%r9
mov    0x40(%rsp),%r11
mov    0x20(%rsp),%r15
mov    0x18(%rsp),%r10
nopl   (%rax)
movups -0x10(%rax,%rdx,4),%xmm3
movups (%rax,%rdx,4),%xmm4
movups 0x4(%rsi,%rdx,4),%xmm5
movups 0x14(%rsi,%rdx,4),%xmm6
mulps  %xmm2,%xmm3
addps  %xmm5,%xmm3
mulps  %xmm2,%xmm4
addps  %xmm6,%xmm4
movups %xmm3,0x4(%rsi,%rdx,4)
movups %xmm4,0x14(%rsi,%rdx,4)
add    $0x8,%rdx
cmp    %rdx,%rdi
jne    13f0 <greedy+0x260>
mov    0x80(%rsp),%rax
cmp    %rdi,%r10
mov    0xc(%rsp),%ebx
je     12e4 <greedy+0x154>
nopw   0x0(%rax,%rax,1)
test   $0x1,%r11b
jne    1349 <greedy+0x1b9>
movss  0x0(%rbp,%rcx,4),%xmm2
mov    0x38(%rsp),%rdx
mulss  (%rdx,%r13,4),%xmm2
add    $0x1,%r13
addss  (%rsi,%rax,4),%xmm2
movss  %xmm2,(%rsi,%rax,4)
lea    0x1(%rax),%rdx
not    %rax
cmp    0x28(%rsp),%rax
je     12e4 <greedy+0x154>
mov    %r11,%rax
sub    %rdx,%rax
lea    (%rsi,%rdx,4),%rsi
add    $0x4,%rsi
lea    (%r15,%r13,4),%rdx
xor    %ebx,%ebx
nop
movss  0x0(%rbp,%rcx,4),%xmm2
mulss  -0x4(%rdx,%rbx,4),%xmm2
addss  -0x4(%rsi,%rbx,4),%xmm2
movss  %xmm2,-0x4(%rsi,%rbx,4)
movss  0x0(%rbp,%rcx,4),%xmm2
mulss  (%rdx,%rbx,4),%xmm2
addss  (%rsi,%rbx,4),%xmm2
movss  %xmm2,(%rsi,%rbx,4)
add    $0x2,%rbx
cmp    %rbx,%rax
jne    1490 <greedy+0x300>
add    %rbx,%r13
jmp    12e0 <greedy+0x150>
mov    0x10(%rsp),%r8
mov    0xc(%rsp),%ebx
mov    0x50(%rsp),%r12
mov    0x30(%rsp),%r14
mov    0x68(%rsp),%r9
mov    0x100(%rsp),%rbp
mov    0x40(%rsp),%r11
mov    0x20(%rsp),%r15
mov    0x18(%rsp),%r10
test   $0x1,%r11b
je     144a <greedy+0x2ba>
jmp    1349 <greedy+0x1b9>
movss  %xmm0,(%r14)
test   %ebx,%ebx
jle    153c <greedy+0x3ac>
mov    (%r8),%rax
mov    %ebx,%r15d
cmp    $0x4,%ebx
jae    154e <greedy+0x3be>
xor    %ecx,%ecx
mov    0x78(%rsp),%ebp
jmp    15c0 <greedy+0x430>
xorps  %xmm0,%xmm0
mov    0x10(%rsp),%r8
mov    0x30(%rsp),%r14
test   %ebx,%ebx
jg     1515 <greedy+0x385>
mov    %ebx,%r15d
movss  0x70(%rsp),%xmm0
mov    0x78(%rsp),%ebp
jmp    15dd <greedy+0x44d>
mov    %r15d,%ecx
and    $0xfffffffc,%ecx
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x4(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x2,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     2123 <greedy+0xf93>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
xor    %esi,%esi
mov    0x78(%rsp),%ebp
movups (%rax,%rsi,4),%xmm2
movups 0x10(%rax,%rsi,4),%xmm3
divps  %xmm1,%xmm2
movups %xmm2,(%rax,%rsi,4)
divps  %xmm1,%xmm3
movups %xmm3,0x10(%rax,%rsi,4)
add    $0x8,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1580 <greedy+0x3f0>
test   $0x1,%dl
je     15b2 <greedy+0x422>
movups (%rax,%rsi,4),%xmm2
divps  %xmm1,%xmm2
movups %xmm2,(%rax,%rsi,4)
cmp    %r15,%rcx
je     15d7 <greedy+0x447>
nopw   0x0(%rax,%rax,1)
movss  (%rax,%rcx,4),%xmm1
divss  %xmm0,%xmm1
movss  %xmm1,(%rax,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r15
jne    15c0 <greedy+0x430>
movss  0x70(%rsp),%xmm0
movslq %ebp,%r13
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
cvtss2sd %xmm0,%xmm0
movsd  %xmm0,0xc0(%rsp)
lea    0x0(,%r15,4),%rcx
mov    %rcx,0xa8(%rsp)
mov    %r15d,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,0x18(%rsp)
add    $0xfffffffffffffff8,%rcx
mov    %rcx,0x40(%rsp)
shr    $0x3,%rcx
add    $0x1,%rcx
mov    %rax,0x70(%rsp)
lea    0x2(%rax),%rdx
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
and    %rcx,%rdx
mov    %rdx,0x80(%rsp)
mov    %r15d,%eax
and    $0xfffffffe,%eax
mov    %rax,0xb8(%rsp)
mov    %r15d,%eax
and    $0x3,%eax
mov    %rax,0xb0(%rsp)
mov    0x38(%rsp),%rax
add    $0x30,%rax
mov    %rax,0x78(%rsp)
mov    $0x1,%ebp
jmp    16bb <greedy+0x52b>
mov    0x48(%rsp),%rbp
add    %r8d,%ebp
mov    0x100(%rsp),%rax
mov    %rax,(%rsp)
mov    0x38(%rsp),%rdi
mov    0x94(%rsp),%esi
mov    %ebx,%edx
mov    %ebp,%ecx
mov    0x10(%rsp),%r8
movsd  0xc0(%rsp),%xmm0
mov    0x68(%rsp),%r9
mov    $0x1,%al
call   10b0 <gla@plt>
test   %eax,%eax
mov    0x30(%rsp),%r14
jne    1e6c <greedy+0xcdc>
cmp    0x64(%rsp),%ebp
jge    20d5 <greedy+0xf45>
mov    %ebp,%eax
mov    %rax,0x58(%rsp)
mov    %rbp,0x48(%rsp)
test   %ebp,%ebp
jle    1730 <greedy+0x5a0>
mov    0x58(%rsp),%rbx
lea    0x0(,%rbx,4),%rdx
mov    %r14,%rdi
xor    %esi,%esi
call   1050 <memset@plt>
cmpl   $0x1,0x48(%rsp)
jne    1e00 <greedy+0xc70>
xor    %ebx,%ebx
testb  $0x1,0x58(%rsp)
mov    0x30(%rsp),%r14
je     1730 <greedy+0x5a0>
movl   $0x0,(%r12,%rbx,4)
cmpl   $0x0,0xc(%rsp)
jle    1730 <greedy+0x5a0>
mov    0x0(%r13,%rbx,8),%rdi
xor    %esi,%esi
mov    0xa8(%rsp),%rdx
call   1050 <memset@plt>
nopl   0x0(%rax,%rax,1)
cmpl   $0x0,0x94(%rsp)
mov    0xc(%rsp),%ebx
mov    0x68(%rsp),%rbp
mov    0x100(%rsp),%r9
jle    1940 <greedy+0x7b0>
xor    %eax,%eax
xor    %r8d,%r8d
jmp    178d <greedy+0x5fd>
cs nopw 0x0(%rax,%rax,1)
mov    0x0(%rbp,%rax,1),%dil
movzbl %dil,%ecx
movss  (%r9,%rax,4),%xmm0
addss  (%r14,%rcx,4),%xmm0
movss  %xmm0,(%r14,%rcx,4)
add    $0x1,%rax
cmp    0x98(%rsp),%rax
je     1940 <greedy+0x7b0>
test   %ebx,%ebx
jle    1760 <greedy+0x5d0>
movzbl 0x0(%rbp,%rax,1),%ecx
mov    0x10(%rsp),%rdx
mov    (%rdx,%rcx,8),%rdx
movslq %r8d,%r8
cmp    $0x8,%r15d
jae    17b0 <greedy+0x620>
xor    %ecx,%ecx
jmp    1878 <greedy+0x6e8>
nop
cmpq   $0x0,0x40(%rsp)
je     1922 <greedy+0x792>
mov    0x78(%rsp),%rcx
lea    (%rcx,%r8,4),%rdi
mov    0x80(%rsp),%rbx
xor    %esi,%esi
mov    0x88(%rsp),%rcx
nopw   0x0(%rax,%rax,1)
movups (%rdx,%rsi,4),%xmm0
movups 0x10(%rdx,%rsi,4),%xmm1
movups -0x30(%rdi,%rsi,4),%xmm2
subps  %xmm2,%xmm0
movups -0x20(%rdi,%rsi,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,(%rcx,%rsi,4)
movups %xmm1,0x10(%rcx,%rsi,4)
movups 0x20(%rdx,%rsi,4),%xmm0
movups 0x30(%rdx,%rsi,4),%xmm1
movups -0x10(%rdi,%rsi,4),%xmm2
subps  %xmm2,%xmm0
movups (%rdi,%rsi,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,0x20(%rcx,%rsi,4)
movups %xmm1,0x30(%rcx,%rsi,4)
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rbx
jne    17e0 <greedy+0x650>
testb  $0x1,0x20(%rsp)
je     1868 <greedy+0x6d8>
lea    (%rsi,%r8,1),%rcx
movups (%rdx,%rsi,4),%xmm0
movups 0x10(%rdx,%rsi,4),%xmm1
mov    0x38(%rsp),%rdi
movups (%rdi,%rcx,4),%xmm2
subps  %xmm2,%xmm0
movups 0x10(%rdi,%rcx,4),%xmm2
subps  %xmm2,%xmm1
mov    0x88(%rsp),%rcx
movups %xmm0,(%rcx,%rsi,4)
movups %xmm1,0x10(%rcx,%rsi,4)
mov    0x18(%rsp),%rsi
add    %rsi,%r8
mov    %rsi,%rcx
cmp    %rsi,%r15
je     18bb <greedy+0x72b>
mov    0x38(%rsp),%rsi
lea    (%rsi,%r8,4),%rsi
mov    0x88(%rsp),%rdi
lea    (%rdi,%rcx,4),%rdi
lea    (%rdx,%rcx,4),%rdx
mov    %r15,%rbx
sub    %rcx,%rbx
xor    %ecx,%ecx
nopl   0x0(%rax)
movss  (%rdx,%rcx,4),%xmm0
subss  (%rsi,%rcx,4),%xmm0
movss  %xmm0,(%rdi,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%rbx
jne    18a0 <greedy+0x710>
add    %rcx,%r8
mov    0xc(%rsp),%ebx
test   %ebx,%ebx
jle    1760 <greedy+0x5d0>
movzbl 0x0(%rbp,%rax,1),%ecx
mov    0x0(%r13,%rcx,8),%rdx
xor    %esi,%esi
mov    0x88(%rsp),%rcx
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
mulss  %xmm0,%xmm0
mulss  (%r9,%rax,4),%xmm0
addss  (%rdx,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
movzbl 0x0(%rbp,%rax,1),%edi
mov    0x0(%r13,%rdi,8),%rdx
movss  (%rdx,%rsi,4),%xmm0
addss  (%r12,%rdi,4),%xmm0
movss  %xmm0,(%r12,%rdi,4)
add    $0x1,%rsi
cmp    %rsi,%r15
jne    18e0 <greedy+0x750>
jmp    1765 <greedy+0x5d5>
xor    %esi,%esi
testb  $0x1,0x20(%rsp)
jne    1836 <greedy+0x6a6>
jmp    1868 <greedy+0x6d8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmpl   $0x0,0x48(%rsp)
mov    0xb8(%rsp),%rbp
jle    1a40 <greedy+0x8b0>
xor    %r14d,%r14d
jmp    1977 <greedy+0x7e7>
call   1090 <sqrtf@plt>
mov    0x0(%r13,%r14,8),%rax
movss  %xmm0,(%rax,%r12,4)
add    $0x1,%r14
cmp    0x58(%rsp),%r14
je     1a40 <greedy+0x8b0>
test   %ebx,%ebx
jle    1968 <greedy+0x7d8>
mov    0x30(%rsp),%rax
movss  (%rax,%r14,4),%xmm1
mov    0x0(%r13,%r14,8),%rax
xor    %r12d,%r12d
cmp    $0x1,%r15d
jne    19c0 <greedy+0x830>
test   $0x1,%r15b
je     1968 <greedy+0x7d8>
movss  (%rax,%r12,4),%xmm0
divss  %xmm1,%xmm0
ucomiss 0x1655(%rip),%xmm0
jb     1958 <greedy+0x7c8>
sqrtss %xmm0,%xmm0
jmp    195d <greedy+0x7cd>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  %xmm1,0x28(%rsp)
jmp    19f0 <greedy+0x860>
nopl   0x0(%rax,%rax,1)
call   1090 <sqrtf@plt>
movss  0x28(%rsp),%xmm1
mov    0x0(%r13,%r14,8),%rax
movss  %xmm0,0x4(%rax,%r12,4)
add    $0x2,%r12
cmp    %r12,%rbp
je     1994 <greedy+0x804>
movss  (%rax,%r12,4),%xmm0
divss  %xmm1,%xmm0
ucomiss 0x15ff(%rip),%xmm0
jb     1a10 <greedy+0x880>
sqrtss %xmm0,%xmm0
jmp    1a1b <greedy+0x88b>
nopl   0x0(%rax)
call   1090 <sqrtf@plt>
movss  0x28(%rsp),%xmm1
mov    0x0(%r13,%r14,8),%rax
movss  %xmm0,(%rax,%r12,4)
movss  0x4(%rax,%r12,4),%xmm0
divss  %xmm1,%xmm0
ucomiss 0x15c8(%rip),%xmm0
jb     19d0 <greedy+0x840>
sqrtss %xmm0,%xmm0
jmp    19db <greedy+0x84b>
mov    0x48(%rsp),%rbp
mov    %ebp,%edi
mov    0x50(%rsp),%r12
mov    %r12,%rsi
mov    0xa0(%rsp),%rdx
xor    %eax,%eax
call   1070 <piksrt@plt>
mov    %ebp,%eax
shr    $0x1f,%eax
add    %ebp,%eax
sar    %eax
lea    (%rax,%rbp,1),%ecx
add    $0x1,%ecx
add    $0x1,%eax
mov    0x64(%rsp),%edx
mov    %edx,%r8d
sub    %ebp,%r8d
cmp    %edx,%ecx
cmovle %eax,%r8d
test   %r8d,%r8d
mov    0xb0(%rsp),%rbp
jle    1670 <greedy+0x4e0>
movslq 0x48(%rsp),%r9
mov    %r8d,%r10d
xor    %r14d,%r14d
jmp    1aad <greedy+0x91d>
xchg   %ax,%ax
add    $0x1,%r14
cmp    %r10,%r14
jae    1670 <greedy+0x4e0>
test   %ebx,%ebx
jle    1aa0 <greedy+0x910>
mov    0xa0(%rsp),%rax
movslq (%rax,%r14,4),%r11
lea    (%r14,%r9,1),%rdx
mov    0x10(%rsp),%rsi
mov    (%rsi,%r11,8),%rax
mov    0x0(%r13,%r11,8),%rcx
mov    (%rsi,%rdx,8),%rdx
cmp    $0x8,%r15d
jae    1ae0 <greedy+0x950>
xor    %edi,%edi
jmp    1bd0 <greedy+0xa40>
lea    (%rdx,%r15,4),%rsi
lea    (%rax,%r15,4),%rdi
lea    (%rcx,%r15,4),%rbx
cmp    %rdi,%rdx
setb   %dil
cmp    %rsi,%rax
setb   %r12b
cmp    %rbx,%rdx
setb   %bl
cmp    %rsi,%rcx
setb   %sil
test   %r12b,%dil
jne    1bc9 <greedy+0xa39>
mov    $0x0,%edi
and    %sil,%bl
mov    0x50(%rsp),%r12
jne    1bd0 <greedy+0xa40>
cmpq   $0x0,0x40(%rsp)
je     1ddd <greedy+0xc4d>
mov    0x80(%rsp),%rbx
xor    %edi,%edi
nopl   0x0(%rax)
movups (%rax,%rdi,4),%xmm0
movups 0x10(%rax,%rdi,4),%xmm1
movups (%rcx,%rdi,4),%xmm2
subps  %xmm2,%xmm0
movups 0x10(%rcx,%rdi,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,(%rdx,%rdi,4)
movups %xmm1,0x10(%rdx,%rdi,4)
movups 0x20(%rax,%rdi,4),%xmm0
movups 0x30(%rax,%rdi,4),%xmm1
movups 0x20(%rcx,%rdi,4),%xmm2
subps  %xmm2,%xmm0
movups 0x30(%rcx,%rdi,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,0x20(%rdx,%rdi,4)
movups %xmm1,0x30(%rdx,%rdi,4)
add    $0x10,%rdi
add    $0xfffffffffffffffe,%rbx
jne    1b40 <greedy+0x9b0>
testb  $0x1,0x20(%rsp)
je     1bb7 <greedy+0xa27>
movups (%rax,%rdi,4),%xmm0
movups 0x10(%rax,%rdi,4),%xmm1
movups (%rcx,%rdi,4),%xmm2
subps  %xmm2,%xmm0
movups 0x10(%rcx,%rdi,4),%xmm2
subps  %xmm2,%xmm1
movups %xmm0,(%rdx,%rdi,4)
movups %xmm1,0x10(%rdx,%rdi,4)
mov    0x18(%rsp),%rsi
mov    %rsi,%rdi
cmp    %rsi,%r15
jne    1bd0 <greedy+0xa40>
jmp    1c5e <greedy+0xace>
xor    %edi,%edi
mov    0x50(%rsp),%r12
mov    %rdi,%rbx
not    %rbx
add    %r15,%rbx
test   %rbp,%rbp
je     1c09 <greedy+0xa79>
mov    %rbp,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rdi,4),%xmm0
subss  (%rcx,%rdi,4),%xmm0
movss  %xmm0,(%rdx,%rdi,4)
add    $0x1,%rdi
add    $0xffffffffffffffff,%rsi
jne    1bf0 <greedy+0xa60>
cmp    $0x3,%rbx
jb     1c5e <greedy+0xace>
nop
movss  (%rax,%rdi,4),%xmm0
subss  (%rcx,%rdi,4),%xmm0
movss  %xmm0,(%rdx,%rdi,4)
movss  0x4(%rax,%rdi,4),%xmm0
subss  0x4(%rcx,%rdi,4),%xmm0
movss  %xmm0,0x4(%rdx,%rdi,4)
movss  0x8(%rax,%rdi,4),%xmm0
subss  0x8(%rcx,%rdi,4),%xmm0
movss  %xmm0,0x8(%rdx,%rdi,4)
movss  0xc(%rax,%rdi,4),%xmm0
subss  0xc(%rcx,%rdi,4),%xmm0
movss  %xmm0,0xc(%rdx,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%r15
jne    1c10 <greedy+0xa80>
mov    0xc(%rsp),%ebx
test   %ebx,%ebx
jle    1aa0 <greedy+0x910>
mov    0x10(%rsp),%rax
mov    (%rax,%r11,8),%rax
mov    0x0(%r13,%r11,8),%rcx
cmp    $0x8,%r15d
jb     1c98 <greedy+0xb08>
lea    (%rcx,%r15,4),%rdx
cmp    %rdx,%rax
jae    1d33 <greedy+0xba3>
lea    (%rax,%r15,4),%rdx
cmp    %rdx,%rcx
jae    1d33 <greedy+0xba3>
xor    %edx,%edx
mov    %rdx,%rdi
not    %rdi
add    %r15,%rdi
test   $0x3,%r15b
je     1cc9 <greedy+0xb39>
mov    %rbp,%rsi
nopl   0x0(%rax)
movss  (%rax,%rdx,4),%xmm0
addss  (%rcx,%rdx,4),%xmm0
movss  %xmm0,(%rax,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rsi
jne    1cb0 <greedy+0xb20>
cmp    $0x3,%rdi
jb     1aa0 <greedy+0x910>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  (%rax,%rdx,4),%xmm0
addss  (%rcx,%rdx,4),%xmm0
movss  0x4(%rax,%rdx,4),%xmm1
movss  %xmm0,(%rax,%rdx,4)
addss  0x4(%rcx,%rdx,4),%xmm1
movss  %xmm1,0x4(%rax,%rdx,4)
movss  0x8(%rax,%rdx,4),%xmm0
addss  0x8(%rcx,%rdx,4),%xmm0
movss  %xmm0,0x8(%rax,%rdx,4)
movss  0xc(%rax,%rdx,4),%xmm0
addss  0xc(%rcx,%rdx,4),%xmm0
movss  %xmm0,0xc(%rax,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%r15
jne    1ce0 <greedy+0xb50>
jmp    1aa0 <greedy+0x910>
cmpq   $0x0,0x40(%rsp)
je     1def <greedy+0xc5f>
mov    0x80(%rsp),%rdi
xor    %edx,%edx
nopl   0x0(%rax)
movups (%rcx,%rdx,4),%xmm0
movups 0x10(%rcx,%rdx,4),%xmm1
movups (%rax,%rdx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rax,%rdx,4),%xmm0
addps  %xmm1,%xmm0
movups 0x20(%rax,%rdx,4),%xmm1
movups 0x30(%rax,%rdx,4),%xmm3
movups %xmm2,(%rax,%rdx,4)
movups %xmm0,0x10(%rax,%rdx,4)
movups 0x20(%rcx,%rdx,4),%xmm0
addps  %xmm1,%xmm0
movups 0x30(%rcx,%rdx,4),%xmm1
addps  %xmm3,%xmm1
movups %xmm0,0x20(%rax,%rdx,4)
movups %xmm1,0x30(%rax,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1d50 <greedy+0xbc0>
testb  $0x1,0x20(%rsp)
je     1dc7 <greedy+0xc37>
movups (%rax,%rdx,4),%xmm0
movups 0x10(%rax,%rdx,4),%xmm1
movups (%rcx,%rdx,4),%xmm2
addps  %xmm0,%xmm2
movups 0x10(%rcx,%rdx,4),%xmm0
addps  %xmm1,%xmm0
movups %xmm2,(%rax,%rdx,4)
movups %xmm0,0x10(%rax,%rdx,4)
mov    0x18(%rsp),%rsi
mov    %rsi,%rdx
cmp    %rsi,%r15
je     1aa0 <greedy+0x910>
jmp    1c9a <greedy+0xb0a>
xor    %edi,%edi
testb  $0x1,0x20(%rsp)
jne    1b96 <greedy+0xa06>
jmp    1bb7 <greedy+0xa27>
xor    %edx,%edx
testb  $0x1,0x20(%rsp)
jne    1da6 <greedy+0xc16>
jmp    1dc7 <greedy+0xc37>
nopw   0x0(%rax,%rax,1)
mov    %ebx,%r14d
and    $0xfffffffe,%r14d
xor    %ebx,%ebx
mov    0xa8(%rsp),%rbp
jmp    1e2d <greedy+0xc9d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x2,%rbx
cmp    %rbx,%r14
je     16f9 <greedy+0x569>
movl   $0x0,(%r12,%rbx,4)
cmpl   $0x0,0xc(%rsp)
jle    1e4b <greedy+0xcbb>
mov    0x0(%r13,%rbx,8),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1050 <memset@plt>
movl   $0x0,0x4(%r12,%rbx,4)
cmpl   $0x0,0xc(%rsp)
jle    1e20 <greedy+0xc90>
mov    0x8(%r13,%rbx,8),%rdi
xor    %esi,%esi
mov    %rbp,%rdx
call   1050 <memset@plt>
jmp    1e20 <greedy+0xc90>
cmp    $0x2,%ebp
jl     20d5 <greedy+0xf45>
mov    %r15d,%eax
and    $0xfffffff8,%eax
mov    %rax,0x58(%rsp)
mov    0x20(%rsp),%rax
mov    %eax,%r14d
and    $0x3,%r14d
and    %rax,0x70(%rsp)
mov    %r15d,%eax
and    $0x3,%eax
mov    %rax,0x38(%rsp)
mov    %r14,0x98(%rsp)
shl    $0x5,%r14
mov    $0x1,%eax
mov    %rax,0x18(%rsp)
xor    %eax,%eax
mov    0x10(%rsp),%r8
jmp    1ee1 <greedy+0xd51>
nopl   0x0(%rax,%rax,1)
lea    -0x1(%rbp),%eax
cltq
addq   $0x1,0x18(%rsp)
mov    0x20(%rsp),%rcx
cmp    %rax,%rcx
mov    %rcx,%rax
mov    0x50(%rsp),%r12
jge    20d5 <greedy+0xf45>
mov    %rax,%rdx
lea    0x1(%rax),%rcx
movslq %ebp,%rax
cmp    %rax,%rcx
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
jge    1ec0 <greedy+0xd30>
mov    0x18(%rsp),%r12
mov    %rdx,0x28(%rsp)
jmp    1f23 <greedy+0xd93>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x10(%rsp),%r8
mov    0x28(%rsp),%rdx
add    $0x1,%r12
cmp    %r12d,%ebp
jle    1ec0 <greedy+0xd30>
mov    (%r8,%rdx,8),%rdi
mov    (%r8,%r12,8),%rsi
mov    %ebx,%edx
xor    %eax,%eax
call   1040 <distance2@plt>
test   %eax,%eax
jne    1f10 <greedy+0xd80>
add    $0xffffffff,%ebp
movslq %ebp,%rax
cmp    %rax,%r12
jge    1f10 <greedy+0xd80>
mov    %r12,%rax
mov    0x10(%rsp),%r8
mov    0x38(%rsp),%r9
jmp    1f64 <greedy+0xdd4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %eax,%ebp
jle    1f15 <greedy+0xd85>
mov    %rax,%rdx
add    $0x1,%rax
test   %ebx,%ebx
jle    1f60 <greedy+0xdd0>
mov    (%r8,%rax,8),%rcx
mov    (%r8,%rdx,8),%rdx
cmp    $0x8,%r15d
jb     1f93 <greedy+0xe03>
lea    (%rcx,%r15,4),%rsi
cmp    %rsi,%rdx
jae    200c <greedy+0xe7c>
lea    (%rdx,%r15,4),%rsi
cmp    %rsi,%rcx
jae    200c <greedy+0xe7c>
xor    %esi,%esi
mov    %rsi,%rdi
not    %rdi
add    %r15,%rdi
test   %r9,%r9
je     1fc4 <greedy+0xe34>
mov    %r9,%rbx
cs nopw 0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
add    $0x1,%rsi
add    $0xffffffffffffffff,%rbx
jne    1fb0 <greedy+0xe20>
cmp    $0x3,%rdi
mov    0xc(%rsp),%ebx
jb     1f60 <greedy+0xdd0>
xchg   %ax,%ax
movss  (%rcx,%rsi,4),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
movss  0x4(%rcx,%rsi,4),%xmm0
movss  %xmm0,0x4(%rdx,%rsi,4)
movss  0x8(%rcx,%rsi,4),%xmm0
movss  %xmm0,0x8(%rdx,%rsi,4)
movss  0xc(%rcx,%rsi,4),%xmm0
movss  %xmm0,0xc(%rdx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%r15
jne    1fd0 <greedy+0xe40>
jmp    1f60 <greedy+0xdd0>
cmpq   $0x18,0x40(%rsp)
jae    2018 <greedy+0xe88>
xor    %esi,%esi
jmp    2078 <greedy+0xee8>
mov    0x70(%rsp),%rdi
xor    %esi,%esi
nop
movups (%rcx,%rsi,4),%xmm0
movups 0x10(%rcx,%rsi,4),%xmm1
movups %xmm0,(%rdx,%rsi,4)
movups %xmm1,0x10(%rdx,%rsi,4)
movups 0x20(%rcx,%rsi,4),%xmm0
movups 0x30(%rcx,%rsi,4),%xmm1
movups %xmm0,0x20(%rdx,%rsi,4)
movups %xmm1,0x30(%rdx,%rsi,4)
movups 0x40(%rcx,%rsi,4),%xmm0
movups 0x50(%rcx,%rsi,4),%xmm1
movups %xmm0,0x40(%rdx,%rsi,4)
movups %xmm1,0x50(%rdx,%rsi,4)
movups 0x60(%rcx,%rsi,4),%xmm0
movups 0x70(%rcx,%rsi,4),%xmm1
movups %xmm0,0x60(%rdx,%rsi,4)
movups %xmm1,0x70(%rdx,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    2020 <greedy+0xe90>
cmpq   $0x0,0x98(%rsp)
je     20bb <greedy+0xf2b>
lea    (%rdx,%rsi,4),%rdi
add    $0x10,%rdi
lea    (%rcx,%rsi,4),%rsi
add    $0x10,%rsi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movups -0x10(%rsi,%rbx,1),%xmm0
movups (%rsi,%rbx,1),%xmm1
movups %xmm0,-0x10(%rdi,%rbx,1)
movups %xmm1,(%rdi,%rbx,1)
add    $0x20,%rbx
cmp    %rbx,%r14
jne    20a0 <greedy+0xf10>
mov    0x58(%rsp),%rdi
mov    %rdi,%rsi
cmp    %rdi,%r15
mov    0xc(%rsp),%ebx
je     1f60 <greedy+0xdd0>
jmp    1f95 <greedy+0xe05>
mov    %r13,%rdi
mov    0x64(%rsp),%esi
xor    %eax,%eax
call   1060 <free_fmatrix@plt>
mov    0x88(%rsp),%rdi
call   1030 <free@plt>
mov    0xa0(%rsp),%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x30(%rsp),%rdi
call   1030 <free@plt>
mov    %ebp,%eax
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
xor    %esi,%esi
mov    0x78(%rsp),%ebp
test   $0x1,%dl
jne    15a7 <greedy+0x417>
jmp    15b2 <greedy+0x422>

LLVM IR (-O0):
define i32 @greedy(float* %0, i32 %1, i32 %2, i32 %3, float** %4, float %5, i8* %6, float* %7) {
%9 = alloca float*
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca float**
%14 = alloca float
%15 = alloca i8*
%16 = alloca float*
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32*
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca float*
%28 = alloca float*
%29 = alloca float**
%30 = alloca float*
store float* %0, float** %9
store i32 %1, i32* %10
store i32 %2, i32* %11
store i32 %3, i32* %12
store float** %4, float*** %13
store float %5, float* %14
store i8* %6, i8** %15
store float* %7, float** %16
%31 = load i32, i32* %12
%32 = load i32, i32* %11
%33 = call i32 (i32, i32, ...) bitcast (i32 (...)* @fmatrix to i32 (i32, i32, ...)*)(i32 %31, i32 %32)
%34 = sext i32 %33 to i64
%35 = inttoptr i64 %34 to float**
store float** %35, float*** %29
%36 = load i32, i32* %11
%37 = sext i32 %36 to i64
%38 = call i8* @calloc(i64 %37, i64 4)
%39 = bitcast i8* %38 to float*
store float* %39, float** %28
%40 = load i32, i32* %12
%41 = sext i32 %40 to i64
%42 = call i8* @calloc(i64 %41, i64 4)
%43 = bitcast i8* %42 to float*
store float* %43, float** %30
%44 = load i32, i32* %12
%45 = sext i32 %44 to i64
%46 = call i8* @calloc(i64 %45, i64 4)
%47 = bitcast i8* %46 to float*
store float* %47, float** %27
%48 = load i32, i32* %12
%49 = sext i32 %48 to i64
%50 = call i8* @calloc(i64 %49, i64 4)
%51 = bitcast i8* %50 to i32*
store i32* %51, i32** %22
store i32 0, i32* %23
br label %52
52: ; preds = %63, %8
%53 = load i32, i32* %23
%54 = load i32, i32* %11
%55 = icmp slt i32 %53, %54
br i1 %55, label %56, label %66
56: ; preds = %52
%57 = load float**, float*** %13
%58 = getelementptr inbounds float*, float** %57, i64 0
%59 = load float*, float** %58
%60 = load i32, i32* %23
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds float, float* %59, i64 %61
store float 0.000000e+00, float* %62
br label %63
63: ; preds = %56
%64 = load i32, i32* %23
%65 = add nsw i32 %64, 1
store i32 %65, i32* %23
br label %52
66: ; preds = %52
%67 = load float*, float** %27
%68 = getelementptr inbounds float, float* %67, i64 0
store float 0.000000e+00, float* %68
store i32 0, i32* %24
store i32 0, i32* %17
br label %69
69: ; preds = %115, %66
%70 = load i32, i32* %17
%71 = load i32, i32* %10
%72 = icmp slt i32 %70, %71
br i1 %72, label %73, label %118
73: ; preds = %69
%74 = load i8*, i8** %15
%75 = load i32, i32* %17
%76 = sext i32 %75 to i64
%77 = getelementptr inbounds i8, i8* %74, i64 %76
store i8 0, i8* %77
%78 = load float*, float** %16
%79 = load i32, i32* %17
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds float, float* %78, i64 %80
%82 = load float, float* %81
%83 = load float*, float** %27
%84 = getelementptr inbounds float, float* %83, i64 0
%85 = load float, float* %84
%86 = fadd float %85, %82
store float %86, float* %84
store i32 0, i32* %23
br label %87
87: ; preds = %111, %73
%88 = load i32, i32* %23
%89 = load i32, i32* %11
%90 = icmp slt i32 %88, %89
br i1 %90, label %91, label %114
91: ; preds = %87
%92 = load float*, float** %16
%93 = load i32, i32* %17
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds float, float* %92, i64 %94
%96 = load float, float* %95
%97 = load float*, float** %9
%98 = load i32, i32* %24
%99 = add nsw i32 %98, 1
store i32 %99, i32* %24
%100 = sext i32 %98 to i64
%101 = getelementptr inbounds float, float* %97, i64 %100
%102 = load float, float* %101
%103 = load float**, float*** %13
%104 = getelementptr inbounds float*, float** %103, i64 0
%105 = load float*, float** %104
%106 = load i32, i32* %23
%107 = sext i32 %106 to i64
%108 = getelementptr inbounds float, float* %105, i64 %107
%109 = load float, float* %108
%110 = call float @llvm.fmuladd.f32(float %96, float %102, float %109)
store float %110, float* %108
br label %111
111: ; preds = %91
%112 = load i32, i32* %23
%113 = add nsw i32 %112, 1
store i32 %113, i32* %23
br label %87
114: ; preds = %87
br label %115
115: ; preds = %114
%116 = load i32, i32* %17
%117 = add nsw i32 %116, 1
store i32 %117, i32* %17
br label %69
118: ; preds = %69
store i32 0, i32* %23
br label %119
119: ; preds = %135, %118
%120 = load i32, i32* %23
%121 = load i32, i32* %11
%122 = icmp slt i32 %120, %121
br i1 %122, label %123, label %138
123: ; preds = %119
%124 = load float*, float** %27
%125 = getelementptr inbounds float, float* %124, i64 0
%126 = load float, float* %125
%127 = load float**, float*** %13
%128 = getelementptr inbounds float*, float** %127, i64 0
%129 = load float*, float** %128
%130 = load i32, i32* %23
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds float, float* %129, i64 %131
%133 = load float, float* %132
%134 = fdiv float %133, %126
store float %134, float* %132
br label %135
135: ; preds = %123
%136 = load i32, i32* %23
%137 = add nsw i32 %136, 1
store i32 %137, i32* %23
br label %119
138: ; preds = %119
store i32 1, i32* %18
br label %139
139: ; preds = %538, %138
%140 = load i32, i32* %18
%141 = load i32, i32* %12
%142 = icmp slt i32 %140, %141
br i1 %142, label %143, label %539
143: ; preds = %139
store i32 0, i32* %19
br label %144
144: ; preds = %174, %143
%145 = load i32, i32* %19
%146 = load i32, i32* %18
%147 = icmp slt i32 %145, %146
br i1 %147, label %148, label %177
148: ; preds = %144
%149 = load float*, float** %30
%150 = load i32, i32* %19
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds float, float* %149, i64 %151
store float 0.000000e+00, float* %152
%153 = load float*, float** %27
%154 = load i32, i32* %19
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds float, float* %153, i64 %155
store float 0.000000e+00, float* %156
store i32 0, i32* %23
br label %157
157: ; preds = %170, %148
%158 = load i32, i32* %23
%159 = load i32, i32* %11
%160 = icmp slt i32 %158, %159
br i1 %160, label %161, label %173
161: ; preds = %157
%162 = load float**, float*** %29
%163 = load i32, i32* %19
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds float*, float** %162, i64 %164
%166 = load float*, float** %165
%167 = load i32, i32* %23
%168 = sext i32 %167 to i64
%169 = getelementptr inbounds float, float* %166, i64 %168
store float 0.000000e+00, float* %169
br label %170
170: ; preds = %161
%171 = load i32, i32* %23
%172 = add nsw i32 %171, 1
store i32 %172, i32* %23
br label %157
173: ; preds = %157
br label %174
174: ; preds = %173
%175 = load i32, i32* %19
%176 = add nsw i32 %175, 1
store i32 %176, i32* %19
br label %144
177: ; preds = %144
store i32 0, i32* %24
store i32 0, i32* %17
br label %178
178: ; preds = %293, %177
%179 = load i32, i32* %17
%180 = load i32, i32* %10
%181 = icmp slt i32 %179, %180
br i1 %181, label %182, label %296
182: ; preds = %178
store i32 0, i32* %23
br label %183
183: ; preds = %212, %182
%184 = load i32, i32* %23
%185 = load i32, i32* %11
%186 = icmp slt i32 %184, %185
br i1 %186, label %187, label %215
187: ; preds = %183
%188 = load float**, float*** %13
%189 = load i8*, i8** %15
%190 = load i32, i32* %17
%191 = sext i32 %190 to i64
%192 = getelementptr inbounds i8, i8* %189, i64 %191
%193 = load i8, i8* %192
%194 = zext i8 %193 to i64
%195 = getelementptr inbounds float*, float** %188, i64 %194
%196 = load float*, float** %195
%197 = load i32, i32* %23
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds float, float* %196, i64 %198
%200 = load float, float* %199
%201 = load float*, float** %9
%202 = load i32, i32* %24
%203 = add nsw i32 %202, 1
store i32 %203, i32* %24
%204 = sext i32 %202 to i64
%205 = getelementptr inbounds float, float* %201, i64 %204
%206 = load float, float* %205
%207 = fsub float %200, %206
%208 = load float*, float** %28
%209 = load i32, i32* %23
%210 = sext i32 %209 to i64
%211 = getelementptr inbounds float, float* %208, i64 %210
store float %207, float* %211
br label %212
212: ; preds = %187
%213 = load i32, i32* %23
%214 = add nsw i32 %213, 1
store i32 %214, i32* %23
br label %183
215: ; preds = %183
store i32 0, i32* %23
br label %216
216: ; preds = %274, %215
%217 = load i32, i32* %23
%218 = load i32, i32* %11
%219 = icmp slt i32 %217, %218
br i1 %219, label %220, label %277
220: ; preds = %216
%221 = load float*, float** %16
%222 = load i32, i32* %17
%223 = sext i32 %222 to i64
%224 = getelementptr inbounds float, float* %221, i64 %223
%225 = load float, float* %224
%226 = load float*, float** %28
%227 = load i32, i32* %23
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds float, float* %226, i64 %228
%230 = load float, float* %229
%231 = load float*, float** %28
%232 = load i32, i32* %23
%233 = sext i32 %232 to i64
%234 = getelementptr inbounds float, float* %231, i64 %233
%235 = load float, float* %234
%236 = fmul float %230, %235
%237 = load float**, float*** %29
%238 = load i8*, i8** %15
%239 = load i32, i32* %17
%240 = sext i32 %239 to i64
%241 = getelementptr inbounds i8, i8* %238, i64 %240
%242 = load i8, i8* %241
%243 = zext i8 %242 to i64
%244 = getelementptr inbounds float*, float** %237, i64 %243
%245 = load float*, float** %244
%246 = load i32, i32* %23
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds float, float* %245, i64 %247
%249 = load float, float* %248
%250 = call float @llvm.fmuladd.f32(float %225, float %236, float %249)
store float %250, float* %248
%251 = load float**, float*** %29
%252 = load i8*, i8** %15
%253 = load i32, i32* %17
%254 = sext i32 %253 to i64
%255 = getelementptr inbounds i8, i8* %252, i64 %254
%256 = load i8, i8* %255
%257 = zext i8 %256 to i64
%258 = getelementptr inbounds float*, float** %251, i64 %257
%259 = load float*, float** %258
%260 = load i32, i32* %23
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds float, float* %259, i64 %261
%263 = load float, float* %262
%264 = load float*, float** %30
%265 = load i8*, i8** %15
%266 = load i32, i32* %17
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds i8, i8* %265, i64 %267
%269 = load i8, i8* %268
%270 = zext i8 %269 to i64
%271 = getelementptr inbounds float, float* %264, i64 %270
%272 = load float, float* %271
%273 = fadd float %272, %263
store float %273, float* %271
br label %274
274: ; preds = %220
%275 = load i32, i32* %23
%276 = add nsw i32 %275, 1
store i32 %276, i32* %23
br label %216
277: ; preds = %216
%278 = load float*, float** %16
%279 = load i32, i32* %17
%280 = sext i32 %279 to i64
%281 = getelementptr inbounds float, float* %278, i64 %280
%282 = load float, float* %281
%283 = load float*, float** %27
%284 = load i8*, i8** %15
%285 = load i32, i32* %17
%286 = sext i32 %285 to i64
%287 = getelementptr inbounds i8, i8* %284, i64 %286
%288 = load i8, i8* %287
%289 = zext i8 %288 to i64
%290 = getelementptr inbounds float, float* %283, i64 %289
%291 = load float, float* %290
%292 = fadd float %291, %282
store float %292, float* %290
br label %293
293: ; preds = %277
%294 = load i32, i32* %17
%295 = add nsw i32 %294, 1
store i32 %295, i32* %17
br label %178
296: ; preds = %178
store i32 0, i32* %19
br label %297
297: ; preds = %337, %296
%298 = load i32, i32* %19
%299 = load i32, i32* %18
%300 = icmp slt i32 %298, %299
br i1 %300, label %301, label %340
301: ; preds = %297
store i32 0, i32* %23
br label %302
302: ; preds = %333, %301
%303 = load i32, i32* %23
%304 = load i32, i32* %11
%305 = icmp slt i32 %303, %304
br i1 %305, label %306, label %336
306: ; preds = %302
%307 = load float**, float*** %29
%308 = load i32, i32* %19
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds float*, float** %307, i64 %309
%311 = load float*, float** %310
%312 = load i32, i32* %23
%313 = sext i32 %312 to i64
%314 = getelementptr inbounds float, float* %311, i64 %313
%315 = load float, float* %314
%316 = load float*, float** %27
%317 = load i32, i32* %19
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds float, float* %316, i64 %318
%320 = load float, float* %319
%321 = fdiv float %315, %320
%322 = fpext float %321 to double
%323 = call double @sqrt(double %322)
%324 = fptrunc double %323 to float
%325 = load float**, float*** %29
%326 = load i32, i32* %19
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds float*, float** %325, i64 %327
%329 = load float*, float** %328
%330 = load i32, i32* %23
%331 = sext i32 %330 to i64
%332 = getelementptr inbounds float, float* %329, i64 %331
store float %324, float* %332
br label %333
333: ; preds = %306
%334 = load i32, i32* %23
%335 = add nsw i32 %334, 1
store i32 %335, i32* %23
br label %302
336: ; preds = %302
br label %337
337: ; preds = %336
%338 = load i32, i32* %19
%339 = add nsw i32 %338, 1
store i32 %339, i32* %19
br label %297
340: ; preds = %297
%341 = load i32, i32* %18
%342 = load float*, float** %30
%343 = load i32*, i32** %22
%344 = call i32 (i32, float*, i32*, ...) bitcast (i32 (...)* @piksrt to i32 (i32, float*, i32*, ...)*)(i32 %341, float* %342, i32* %343)
%345 = load i32, i32* %18
%346 = sdiv i32 %345, 2
%347 = add nsw i32 %346, 1
store i32 %347, i32* %21
%348 = load i32, i32* %21
%349 = load i32, i32* %18
%350 = add nsw i32 %348, %349
%351 = load i32, i32* %12
%352 = icmp sgt i32 %350, %351
br i1 %352, label %353, label %357
353: ; preds = %340
%354 = load i32, i32* %12
%355 = load i32, i32* %18
%356 = sub nsw i32 %354, %355
store i32 %356, i32* %21
br label %357
357: ; preds = %353, %340
store i32 0, i32* %19
br label %358
358: ; preds = %442, %357
%359 = load i32, i32* %19
%360 = load i32, i32* %21
%361 = icmp slt i32 %359, %360
br i1 %361, label %362, label %445
362: ; preds = %358
%363 = load i32*, i32** %22
%364 = load i32, i32* %19
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds i32, i32* %363, i64 %365
%367 = load i32, i32* %366
store i32 %367, i32* %20
store i32 0, i32* %23
br label %368
368: ; preds = %402, %362
%369 = load i32, i32* %23
%370 = load i32, i32* %11
%371 = icmp slt i32 %369, %370
br i1 %371, label %372, label %405
372: ; preds = %368
%373 = load float**, float*** %13
%374 = load i32, i32* %20
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds float*, float** %373, i64 %375
%377 = load float*, float** %376
%378 = load i32, i32* %23
%379 = sext i32 %378 to i64
%380 = getelementptr inbounds float, float* %377, i64 %379
%381 = load float, float* %380
%382 = load float**, float*** %29
%383 = load i32, i32* %20
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds float*, float** %382, i64 %384
%386 = load float*, float** %385
%387 = load i32, i32* %23
%388 = sext i32 %387 to i64
%389 = getelementptr inbounds float, float* %386, i64 %388
%390 = load float, float* %389
%391 = fsub float %381, %390
%392 = load float**, float*** %13
%393 = load i32, i32* %18
%394 = load i32, i32* %19
%395 = add nsw i32 %393, %394
%396 = sext i32 %395 to i64
%397 = getelementptr inbounds float*, float** %392, i64 %396
%398 = load float*, float** %397
%399 = load i32, i32* %23
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds float, float* %398, i64 %400
store float %391, float* %401
br label %402
402: ; preds = %372
%403 = load i32, i32* %23
%404 = add nsw i32 %403, 1
store i32 %404, i32* %23
br label %368
405: ; preds = %368
store i32 0, i32* %23
br label %406
406: ; preds = %438, %405
%407 = load i32, i32* %23
%408 = load i32, i32* %11
%409 = icmp slt i32 %407, %408
br i1 %409, label %410, label %441
410: ; preds = %406
%411 = load float**, float*** %13
%412 = load i32, i32* %20
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds float*, float** %411, i64 %413
%415 = load float*, float** %414
%416 = load i32, i32* %23
%417 = sext i32 %416 to i64
%418 = getelementptr inbounds float, float* %415, i64 %417
%419 = load float, float* %418
%420 = load float**, float*** %29
%421 = load i32, i32* %20
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds float*, float** %420, i64 %422
%424 = load float*, float** %423
%425 = load i32, i32* %23
%426 = sext i32 %425 to i64
%427 = getelementptr inbounds float, float* %424, i64 %426
%428 = load float, float* %427
%429 = fadd float %419, %428
%430 = load float**, float*** %13
%431 = load i32, i32* %20
%432 = sext i32 %431 to i64
%433 = getelementptr inbounds float*, float** %430, i64 %432
%434 = load float*, float** %433
%435 = load i32, i32* %23
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds float, float* %434, i64 %436
store float %429, float* %437
br label %438
438: ; preds = %410
%439 = load i32, i32* %23
%440 = add nsw i32 %439, 1
store i32 %440, i32* %23
br label %406
441: ; preds = %406
br label %442
442: ; preds = %441
%443 = load i32, i32* %19
%444 = add nsw i32 %443, 1
store i32 %444, i32* %19
br label %358
445: ; preds = %358
%446 = load i32, i32* %18
%447 = load i32, i32* %21
%448 = add nsw i32 %446, %447
store i32 %448, i32* %18
%449 = load float*, float** %9
%450 = load i32, i32* %10
%451 = load i32, i32* %11
%452 = load i32, i32* %18
%453 = load float**, float*** %13
%454 = load float, float* %14
%455 = fpext float %454 to double
%456 = load i8*, i8** %15
%457 = load float*, float** %16
%458 = call i32 (float*, i32, i32, i32, float**, double, i8*, float*, ...) bitcast (i32 (...)* @gla to i32 (float*, i32, i32, i32, float**, double, i8*, float*, ...)*)(float* %449, i32 %450, i32 %451, i32 %452, float** %453, double %455, i8* %456, float* %457)
store i32 %458, i32* %25
%459 = load i32, i32* %25
%460 = icmp ne i32 %459, 0
br i1 %460, label %461, label %538
461: ; preds = %445
store i32 0, i32* %19
br label %462
462: ; preds = %534, %461
%463 = load i32, i32* %19
%464 = load i32, i32* %18
%465 = sub nsw i32 %464, 1
%466 = icmp slt i32 %463, %465
br i1 %466, label %467, label %537
467: ; preds = %462
%468 = load i32, i32* %19
%469 = add nsw i32 %468, 1
store i32 %469, i32* %26
br label %470
470: ; preds = %530, %467
%471 = load i32, i32* %26
%472 = load i32, i32* %18
%473 = icmp slt i32 %471, %472
br i1 %473, label %474, label %533
474: ; preds = %470
%475 = load float**, float*** %13
%476 = load i32, i32* %19
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds float*, float** %475, i64 %477
%479 = load float*, float** %478
%480 = load float**, float*** %13
%481 = load i32, i32* %26
%482 = sext i32 %481 to i64
%483 = getelementptr inbounds float*, float** %480, i64 %482
%484 = load float*, float** %483
%485 = load i32, i32* %11
%486 = call i32 (float*, float*, i32, ...) bitcast (i32 (...)* @distance2 to i32 (float*, float*, i32, ...)*)(float* %479, float* %484, i32 %485)
%487 = icmp eq i32 %486, 0
br i1 %487, label %488, label %529
488: ; preds = %474
%489 = load i32, i32* %26
store i32 %489, i32* %24
br label %490
490: ; preds = %523, %488
%491 = load i32, i32* %24
%492 = load i32, i32* %18
%493 = sub nsw i32 %492, 1
%494 = icmp slt i32 %491, %493
br i1 %494, label %495, label %526
495: ; preds = %490
store i32 0, i32* %23
br label %496
496: ; preds = %519, %495
%497 = load i32, i32* %23
%498 = load i32, i32* %11
%499 = icmp slt i32 %497, %498
br i1 %499, label %500, label %522
500: ; preds = %496
%501 = load float**, float*** %13
%502 = load i32, i32* %24
%503 = add nsw i32 %502, 1
%504 = sext i32 %503 to i64
%505 = getelementptr inbounds float*, float** %501, i64 %504
%506 = load float*, float** %505
%507 = load i32, i32* %23
%508 = sext i32 %507 to i64
%509 = getelementptr inbounds float, float* %506, i64 %508
%510 = load float, float* %509
%511 = load float**, float*** %13
%512 = load i32, i32* %24
%513 = sext i32 %512 to i64
%514 = getelementptr inbounds float*, float** %511, i64 %513
%515 = load float*, float** %514
%516 = load i32, i32* %23
%517 = sext i32 %516 to i64
%518 = getelementptr inbounds float, float* %515, i64 %517
store float %510, float* %518
br label %519
519: ; preds = %500
%520 = load i32, i32* %23
%521 = add nsw i32 %520, 1
store i32 %521, i32* %23
br label %496
522: ; preds = %496
br label %523
523: ; preds = %522
%524 = load i32, i32* %24
%525 = add nsw i32 %524, 1
store i32 %525, i32* %24
br label %490
526: ; preds = %490
%527 = load i32, i32* %18
%528 = add nsw i32 %527, -1
store i32 %528, i32* %18
br label %529
529: ; preds = %526, %474
br label %530
530: ; preds = %529
%531 = load i32, i32* %26
%532 = add nsw i32 %531, 1
store i32 %532, i32* %26
br label %470
533: ; preds = %470
br label %534
534: ; preds = %533
%535 = load i32, i32* %19
%536 = add nsw i32 %535, 1
store i32 %536, i32* %19
br label %462
537: ; preds = %462
br label %539
538: ; preds = %445
br label %139
539: ; preds = %537, %139
%540 = load float**, float*** %29
%541 = load i32, i32* %12
%542 = call i32 (float**, i32, ...) bitcast (i32 (...)* @free_fmatrix to i32 (float**, i32, ...)*)(float** %540, i32 %541)
%543 = load float*, float** %28
%544 = bitcast float* %543 to i8*
%545 = load i32*, i32** %22
%546 = bitcast i32* %545 to i8*
%547 = load float*, float** %30
%548 = bitcast float* %547 to i8*
%549 = load float*, float** %27
%550 = bitcast float* %549 to i8*
%551 = load i32, i32* %18
ret i32 %551
}

LLVM IR (-O2):
define i32 @greedy(float* %0, i32 %1, i32 %2, i32 %3, float** %4, float %5, i8* %6, float* %7) {
%9 = tail call i32 (i32, i32, ...) bitcast (i32 (...)* @fmatrix to i32 (i32, i32, ...)*)(i32 %3, i32 %2)
%10 = sext i32 %9 to i64
%11 = inttoptr i64 %10 to float**
%12 = sext i32 %2 to i64
%13 = tail call i8* @calloc(i64 %12, i64 4)
%14 = bitcast i8* %13 to float*
%15 = sext i32 %3 to i64
%16 = tail call i8* @calloc(i64 %15, i64 4)
%17 = bitcast i8* %16 to float*
%18 = tail call i8* @calloc(i64 %15, i64 4)
%19 = bitcast i8* %18 to float*
%20 = tail call i8* @calloc(i64 %15, i64 4)
%21 = bitcast i8* %20 to i32*
%22 = icmp sgt i32 %2, 0
br i1 %22, label %23, label %28
23: ; preds = %8
%24 = bitcast float** %4 to i8**
%25 = load i8*, i8** %24
%26 = zext i32 %2 to i64
%27 = shl nuw nsw i64 %26, 2
br label %28
28: ; preds = %23, %8
%29 = icmp sgt i32 %1, 0
br i1 %29, label %30, label %45
30: ; preds = %28
%31 = zext i32 %1 to i64
%32 = zext i32 %2 to i64
%33 = getelementptr float, float* %0, i64 1
%34 = getelementptr float, float* %0, i64 %32
%35 = add nsw i64 %32, -1
%36 = icmp eq i32 %2, 1
%37 = icmp ult i64 %35, 8
%38 = and i64 %35, -8
%39 = or i64 %38, 1
%40 = icmp eq i64 %35, %38
%41 = and i64 %32, 1
%42 = icmp eq i64 %41, 0
%43 = sub nsw i64 0, %32
br label %94
44: ; preds = %197
store float %104, float* %19
br label %45
45: ; preds = %44, %28
%46 = phi float [ %104, %44 ], [ 0.000000e+00, %28 ]
br i1 %22, label %49, label %47
47: ; preds = %45
%48 = zext i32 %2 to i64
br label %201
49: ; preds = %45
%50 = load float*, float** %4
%51 = zext i32 %2 to i64
%52 = icmp ult i32 %2, 4
br i1 %52, label %92, label %53
53: ; preds = %49
%54 = and i64 %51, 4294967292
%55 = insertelement <4 x float> poison, float %46, i64 0
%56 = shufflevector <4 x float> %55, <4 x float> poison, <4 x i32> zeroinitializer
%57 = add nsw i64 %54, -4
%58 = lshr exact i64 %57, 2
%59 = add nuw nsw i64 %58, 1
%60 = and i64 %59, 1
%61 = icmp eq i64 %57, 0
br i1 %61, label %81, label %62
62: ; preds = %53
%63 = and i64 %59, 9223372036854775806
br label %64
64: ; preds = %64, %62
%65 = phi i64 [ 0, %62 ], [ %78, %64 ]
%66 = phi i64 [ 0, %62 ], [ %79, %64 ]
%67 = getelementptr inbounds float, float* %50, i64 %65
%68 = bitcast float* %67 to <4 x float>*
%69 = load <4 x float>, <4 x float>* %68
%70 = fdiv <4 x float> %69, %56
%71 = bitcast float* %67 to <4 x float>*
store <4 x float> %70, <4 x float>* %71
%72 = or i64 %65, 4
%73 = getelementptr inbounds float, float* %50, i64 %72
%74 = bitcast float* %73 to <4 x float>*
%75 = load <4 x float>, <4 x float>* %74
%76 = fdiv <4 x float> %75, %56
%77 = bitcast float* %73 to <4 x float>*
store <4 x float> %76, <4 x float>* %77
%78 = add nuw i64 %65, 8
%79 = add i64 %66, 2
%80 = icmp eq i64 %79, %63
br i1 %80, label %81, label %64
81: ; preds = %64, %53
%82 = phi i64 [ 0, %53 ], [ %78, %64 ]
%83 = icmp eq i64 %60, 0
br i1 %83, label %90, label %84
84: ; preds = %81
%85 = getelementptr inbounds float, float* %50, i64 %82
%86 = bitcast float* %85 to <4 x float>*
%87 = load <4 x float>, <4 x float>* %86
%88 = fdiv <4 x float> %87, %56
%89 = bitcast float* %85 to <4 x float>*
store <4 x float> %88, <4 x float>* %89
br label %90
90: ; preds = %81, %84
%91 = icmp eq i64 %54, %51
br i1 %91, label %201, label %92
92: ; preds = %49, %90
%93 = phi i64 [ 0, %49 ], [ %54, %90 ]
br label %239
94: ; preds = %30, %197
%95 = phi i64 [ 0, %30 ], [ %199, %197 ]
%96 = phi float [ 0.000000e+00, %30 ], [ %104, %197 ]
%97 = phi i32 [ 0, %30 ], [ %198, %197 ]
%98 = getelementptr float, float* %7, i64 %95
%99 = add nuw i64 %95, 1
%100 = getelementptr float, float* %7, i64 %99
%101 = getelementptr inbounds i8, i8* %6, i64 %95
store i8 0, i8* %101
%102 = getelementptr inbounds float, float* %7, i64 %95
%103 = load float, float* %102
%104 = fadd float %103, %96
br i1 %22, label %105, label %197
105: ; preds = %94
%106 = load float*, float** %4
%107 = sext i32 %97 to i64
%108 = add nsw i64 %107, 1
%109 = getelementptr inbounds float, float* %0, i64 %107
%110 = load float, float* %109
%111 = load float, float* %106
%112 = tail call float @llvm.fmuladd.f32(float %103, float %110, float %111)
store float %112, float* %106
br i1 %36, label %194, label %113
113: ; preds = %105
br i1 %37, label %156, label %114
114: ; preds = %113
%115 = getelementptr float, float* %106, i64 1
%116 = getelementptr float, float* %106, i64 %32
%117 = getelementptr float, float* %33, i64 %107
%118 = getelementptr float, float* %34, i64 %107
%119 = icmp ult float* %115, %100
%120 = icmp ult float* %98, %116
%121 = and i1 %119, %120
%122 = icmp ult float* %115, %118
%123 = icmp ult float* %117, %116
%124 = and i1 %122, %123
%125 = or i1 %121, %124
br i1 %125, label %156, label %126
126: ; preds = %114
%127 = add nsw i64 %108, %38
%128 = load float, float* %102
%129 = insertelement <4 x float> poison, float %128, i64 0
%130 = shufflevector <4 x float> %129, <4 x float> poison, <4 x i32> zeroinitializer
%131 = insertelement <4 x float> poison, float %128, i64 0
%132 = shufflevector <4 x float> %131, <4 x float> poison, <4 x i32> zeroinitializer
br label %133
133: ; preds = %133, %126
%134 = phi i64 [ 0, %126 ], [ %153, %133 ]
%135 = or i64 %134, 1
%136 = add i64 %108, %134
%137 = getelementptr inbounds float, float* %0, i64 %136
%138 = bitcast float* %137 to <4 x float>*
%139 = load <4 x float>, <4 x float>* %138
%140 = getelementptr inbounds float, float* %137, i64 4
%141 = bitcast float* %140 to <4 x float>*
%142 = load <4 x float>, <4 x float>* %141
%143 = getelementptr inbounds float, float* %106, i64 %135
%144 = bitcast float* %143 to <4 x float>*
%145 = load <4 x float>, <4 x float>* %144
%146 = getelementptr inbounds float, float* %143, i64 4
%147 = bitcast float* %146 to <4 x float>*
%148 = load <4 x float>, <4 x float>* %147
%149 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %130, <4 x float> %139, <4 x float> %145)
%150 = call <4 x float> @llvm.fmuladd.v4f32(<4 x float> %132, <4 x float> %142, <4 x float> %148)
%151 = bitcast float* %143 to <4 x float>*
store <4 x float> %149, <4 x float>* %151
%152 = bitcast float* %146 to <4 x float>*
store <4 x float> %150, <4 x float>* %152
%153 = add nuw i64 %134, 8
%154 = icmp eq i64 %153, %38
br i1 %154, label %155, label %133
155: ; preds = %133
br i1 %40, label %194, label %156
156: ; preds = %114, %113, %155
%157 = phi i64 [ 1, %114 ], [ 1, %113 ], [ %39, %155 ]
%158 = phi i64 [ %108, %114 ], [ %108, %113 ], [ %127, %155 ]
%159 = xor i64 %157, -1
br i1 %42, label %160, label %169
160: ; preds = %156
%161 = load float, float* %102
%162 = add nsw i64 %158, 1
%163 = getelementptr inbounds float, float* %0, i64 %158
%164 = load float, float* %163
%165 = getelementptr inbounds float, float* %106, i64 %157
%166 = load float, float* %165
%167 = tail call float @llvm.fmuladd.f32(float %161, float %164, float %166)
store float %167, float* %165
%168 = add nuw nsw i64 %157, 1
br label %169
169: ; preds = %160, %156
%170 = phi i64 [ undef, %156 ], [ %162, %160 ]
%171 = phi i64 [ %157, %156 ], [ %168, %160 ]
%172 = phi i64 [ %158, %156 ], [ %162, %160 ]
%173 = icmp eq i64 %159, %43
br i1 %173, label %194, label %174
174: ; preds = %169, %174
%175 = phi i64 [ %192, %174 ], [ %171, %169 ]
%176 = phi i64 [ %186, %174 ], [ %172, %169 ]
%177 = load float, float* %102
%178 = add nsw i64 %176, 1
%179 = getelementptr inbounds float, float* %0, i64 %176
%180 = load float, float* %179
%181 = getelementptr inbounds float, float* %106, i64 %175
%182 = load float, float* %181
%183 = tail call float @llvm.fmuladd.f32(float %177, float %180, float %182)
store float %183, float* %181
%184 = add nuw nsw i64 %175, 1
%185 = load float, float* %102
%186 = add nsw i64 %176, 2
%187 = getelementptr inbounds float, float* %0, i64 %178
%188 = load float, float* %187
%189 = getelementptr inbounds float, float* %106, i64 %184
%190 = load float, float* %189
%191 = tail call float @llvm.fmuladd.f32(float %185, float %188, float %190)
store float %191, float* %189
%192 = add nuw nsw i64 %175, 2
%193 = icmp eq i64 %192, %32
br i1 %193, label %194, label %174
194: ; preds = %169, %174, %155, %105
%195 = phi i64 [ %108, %105 ], [ %127, %155 ], [ %170, %169 ], [ %186, %174 ]
%196 = trunc i64 %195 to i32
br label %197
197: ; preds = %194, %94
%198 = phi i32 [ %97, %94 ], [ %196, %194 ]
%199 = add nuw nsw i64 %95, 1
%200 = icmp eq i64 %199, %31
br i1 %200, label %44, label %94
201: ; preds = %239, %90, %47
%202 = phi i64 [ %48, %47 ], [ %51, %90 ], [ %51, %239 ]
%203 = fpext float %5 to double
%204 = shl nuw nsw i64 %202, 2
%205 = zext i32 %1 to i64
%206 = and i64 %202, 4294967288
%207 = add nsw i64 %206, -8
%208 = lshr exact i64 %207, 3
%209 = add nuw nsw i64 %208, 1
%210 = icmp ult i64 %202, 8
%211 = and i64 %202, 4294967288
%212 = and i64 %209, 1
%213 = icmp eq i64 %207, 0
%214 = and i64 %209, 4611686018427387902
%215 = icmp eq i64 %212, 0
%216 = icmp eq i64 %202, %211
%217 = and i64 %202, 1
%218 = icmp eq i64 %202, 1
%219 = and i64 %202, 4294967294
%220 = icmp eq i64 %217, 0
%221 = icmp ult i64 %202, 8
%222 = and i64 %202, 4294967288
%223 = and i64 %209, 1
%224 = icmp eq i64 %207, 0
%225 = and i64 %209, 4611686018427387902
%226 = icmp eq i64 %223, 0
%227 = icmp eq i64 %202, %222
%228 = and i64 %202, 3
%229 = icmp eq i64 %228, 0
%230 = icmp ult i64 %202, 8
%231 = and i64 %202, 4294967288
%232 = and i64 %209, 1
%233 = icmp eq i64 %207, 0
%234 = and i64 %209, 4611686018427387902
%235 = icmp eq i64 %232, 0
%236 = icmp eq i64 %202, %231
%237 = and i64 %202, 3
%238 = icmp eq i64 %237, 0
br label %246
239: ; preds = %92, %239
%240 = phi i64 [ %244, %239 ], [ %93, %92 ]
%241 = getelementptr inbounds float, float* %50, i64 %240
%242 = load float, float* %241
%243 = fdiv float %242, %46
store float %243, float* %241
%244 = add nuw nsw i64 %240, 1
%245 = icmp eq i64 %244, %51
br i1 %245, label %201, label %239
246: ; preds = %201, %744
%247 = phi i32 [ %745, %744 ], [ 1, %201 ]
%248 = icmp slt i32 %247, %3
br i1 %248, label %249, label %913
249: ; preds = %246
%250 = icmp sgt i32 %247, 0
br i1 %250, label %251, label %267
251: ; preds = %249
%252 = zext i32 %247 to i64
%253 = shl nuw nsw i64 %252, 2
%254 = and i64 %252, 1
%255 = icmp eq i32 %247, 1
br i1 %255, label %258, label %256
256: ; preds = %251
%257 = and i64 %252, 4294967294
br label %268
258: ; preds = %283, %251
%259 = phi i64 [ 0, %251 ], [ %284, %283 ]
%260 = icmp eq i64 %254, 0
br i1 %260, label %267, label %261
261: ; preds = %258
%262 = getelementptr inbounds float, float* %17, i64 %259
store float 0.000000e+00, float* %262
br i1 %22, label %263, label %267
263: ; preds = %261
%264 = getelementptr inbounds float*, float** %11, i64 %259
%265 = bitcast float** %264 to i8**
%266 = load i8*, i8** %265
br label %267
267: ; preds = %258, %263, %261, %249
br i1 %29, label %290, label %287
268: ; preds = %283, %256
%269 = phi i64 [ 0, %256 ], [ %284, %283 ]
%270 = phi i64 [ 0, %256 ], [ %285, %283 ]
%271 = getelementptr inbounds float, float* %17, i64 %269
store float 0.000000e+00, float* %271
br i1 %22, label %272, label %276
272: ; preds = %268
%273 = getelementptr inbounds float*, float** %11, i64 %269
%274 = bitcast float** %273 to i8**
%275 = load i8*, i8** %274
br label %276
276: ; preds = %272, %268
%277 = or i64 %269, 1
%278 = getelementptr inbounds float, float* %17, i64 %277
store float 0.000000e+00, float* %278
br i1 %22, label %279, label %283
279: ; preds = %276
%280 = getelementptr inbounds float*, float** %11, i64 %277
%281 = bitcast float** %280 to i8**
%282 = load i8*, i8** %281
br label %283
283: ; preds = %279, %276
%284 = add nuw nsw i64 %269, 2
%285 = add i64 %270, 2
%286 = icmp eq i64 %285, %257
br i1 %286, label %258, label %268
287: ; preds = %420, %267
br i1 %250, label %288, label %471
288: ; preds = %287
%289 = zext i32 %247 to i64
br label %431
290: ; preds = %267, %420
%291 = phi i64 [ %429, %420 ], [ 0, %267 ]
%292 = phi i32 [ %422, %420 ], [ 0, %267 ]
br i1 %22, label %293, label %376
293: ; preds = %290
%294 = getelementptr inbounds i8, i8* %6, i64 %291
%295 = load i8, i8* %294
%296 = zext i8 %295 to i64
%297 = getelementptr inbounds float*, float** %4, i64 %296
%298 = load float*, float** %297
%299 = sext i32 %292 to i64
br i1 %210, label %370, label %300
300: ; preds = %293
%301 = add nsw i64 %211, %299
br i1 %213, label %347, label %302
302: ; preds = %300, %302
%303 = phi i64 [ %344, %302 ], [ 0, %300 ]
%304 = phi i64 [ %345, %302 ], [ 0, %300 ]
%305 = add i64 %303, %299
%306 = getelementptr inbounds float, float* %298, i64 %303
%307 = bitcast float* %306 to <4 x float>*
%308 = load <4 x float>, <4 x float>* %307
%309 = getelementptr inbounds float, float* %306, i64 4
%310 = bitcast float* %309 to <4 x float>*
%311 = load <4 x float>, <4 x float>* %310
%312 = getelementptr inbounds float, float* %0, i64 %305
%313 = bitcast float* %312 to <4 x float>*
%314 = load <4 x float>, <4 x float>* %313
%315 = getelementptr inbounds float, float* %312, i64 4
%316 = bitcast float* %315 to <4 x float>*
%317 = load <4 x float>, <4 x float>* %316
%318 = fsub <4 x float> %308, %314
%319 = fsub <4 x float> %311, %317
%320 = getelementptr inbounds float, float* %14, i64 %303
%321 = bitcast float* %320 to <4 x float>*
store <4 x float> %318, <4 x float>* %321
%322 = getelementptr inbounds float, float* %320, i64 4
%323 = bitcast float* %322 to <4 x float>*
store <4 x float> %319, <4 x float>* %323
%324 = or i64 %303, 8
%325 = add i64 %324, %299
%326 = getelementptr inbounds float, float* %298, i64 %324
%327 = bitcast float* %326 to <4 x float>*
%328 = load <4 x float>, <4 x float>* %327
%329 = getelementptr inbounds float, float* %326, i64 4
%330 = bitcast float* %329 to <4 x float>*
%331 = load <4 x float>, <4 x float>* %330
%332 = getelementptr inbounds float, float* %0, i64 %325
%333 = bitcast float* %332 to <4 x float>*
%334 = load <4 x float>, <4 x float>* %333
%335 = getelementptr inbounds float, float* %332, i64 4
%336 = bitcast float* %335 to <4 x float>*
%337 = load <4 x float>, <4 x float>* %336
%338 = fsub <4 x float> %328, %334
%339 = fsub <4 x float> %331, %337
%340 = getelementptr inbounds float, float* %14, i64 %324
%341 = bitcast float* %340 to <4 x float>*
store <4 x float> %338, <4 x float>* %341
%342 = getelementptr inbounds float, float* %340, i64 4
%343 = bitcast float* %342 to <4 x float>*
store <4 x float> %339, <4 x float>* %343
%344 = add nuw i64 %303, 16
%345 = add i64 %304, 2
%346 = icmp eq i64 %345, %214
br i1 %346, label %347, label %302
347: ; preds = %302, %300
%348 = phi i64 [ 0, %300 ], [ %344, %302 ]
br i1 %215, label %369, label %349
349: ; preds = %347
%350 = add i64 %348, %299
%351 = getelementptr inbounds float, float* %298, i64 %348
%352 = bitcast float* %351 to <4 x float>*
%353 = load <4 x float>, <4 x float>* %352
%354 = getelementptr inbounds float, float* %351, i64 4
%355 = bitcast float* %354 to <4 x float>*
%356 = load <4 x float>, <4 x float>* %355
%357 = getelementptr inbounds float, float* %0, i64 %350
%358 = bitcast float* %357 to <4 x float>*
%359 = load <4 x float>, <4 x float>* %358
%360 = getelementptr inbounds float, float* %357, i64 4
%361 = bitcast float* %360 to <4 x float>*
%362 = load <4 x float>, <4 x float>* %361
%363 = fsub <4 x float> %353, %359
%364 = fsub <4 x float> %356, %362
%365 = getelementptr inbounds float, float* %14, i64 %348
%366 = bitcast float* %365 to <4 x float>*
store <4 x float> %363, <4 x float>* %366
%367 = getelementptr inbounds float, float* %365, i64 4
%368 = bitcast float* %367 to <4 x float>*
store <4 x float> %364, <4 x float>* %368
br label %369
369: ; preds = %347, %349
br i1 %216, label %373, label %370
370: ; preds = %293, %369
%371 = phi i64 [ %299, %293 ], [ %301, %369 ]
%372 = phi i64 [ 0, %293 ], [ %211, %369 ]
br label %387
373: ; preds = %387, %369
%374 = phi i64 [ %301, %369 ], [ %392, %387 ]
%375 = trunc i64 %374 to i32
br i1 %22, label %380, label %376
376: ; preds = %290, %373
%377 = phi i32 [ %375, %373 ], [ %292, %290 ]
%378 = getelementptr inbounds i8, i8* %6, i64 %291
%379 = load i8, i8* %378
br label %420
380: ; preds = %373
%381 = getelementptr inbounds float, float* %7, i64 %291
%382 = getelementptr inbounds i8, i8* %6, i64 %291
%383 = load i8, i8* %382
%384 = zext i8 %383 to i64
%385 = getelementptr inbounds float*, float** %11, i64 %384
%386 = load float*, float** %385
br label %399
387: ; preds = %370, %387
%388 = phi i64 [ %392, %387 ], [ %371, %370 ]
%389 = phi i64 [ %397, %387 ], [ %372, %370 ]
%390 = getelementptr inbounds float, float* %298, i64 %389
%391 = load float, float* %390
%392 = add nsw i64 %388, 1
%393 = getelementptr inbounds float, float* %0, i64 %388
%394 = load float, float* %393
%395 = fsub float %391, %394
%396 = getelementptr inbounds float, float* %14, i64 %389
store float %395, float* %396
%397 = add nuw nsw i64 %389, 1
%398 = icmp eq i64 %397, %202
br i1 %398, label %373, label %387
399: ; preds = %380, %399
%400 = phi float* [ %386, %380 ], [ %412, %399 ]
%401 = phi i64 [ 0, %380 ], [ %418, %399 ]
%402 = load float, float* %381
%403 = getelementptr inbounds float, float* %14, i64 %401
%404 = load float, float* %403
%405 = fmul float %404, %404
%406 = getelementptr inbounds float, float* %400, i64 %401
%407 = load float, float* %406
%408 = tail call float @llvm.fmuladd.f32(float %402, float %405, float %407)
store float %408, float* %406
%409 = load i8, i8* %382
%410 = zext i8 %409 to i64
%411 = getelementptr inbounds float*, float** %11, i64 %410
%412 = load float*, float** %411
%413 = getelementptr inbounds float, float* %412, i64 %401
%414 = load float, float* %413
%415 = getelementptr inbounds float, float* %17, i64 %410
%416 = load float, float* %415
%417 = fadd float %414, %416
store float %417, float* %415
%418 = add nuw nsw i64 %401, 1
%419 = icmp eq i64 %418, %202
br i1 %419, label %420, label %399
420: ; preds = %399, %376
%421 = phi i8 [ %379, %376 ], [ %409, %399 ]
%422 = phi i32 [ %377, %376 ], [ %375, %399 ]
%423 = zext i8 %421 to i64
%424 = getelementptr inbounds float, float* %7, i64 %291
%425 = load float, float* %424
%426 = getelementptr inbounds float, float* %19, i64 %423
%427 = load float, float* %426
%428 = fadd float %425, %427
store float %428, float* %426
%429 = add nuw nsw i64 %291, 1
%430 = icmp eq i64 %429, %205
br i1 %430, label %287, label %290
431: ; preds = %288, %468
%432 = phi i64 [ 0, %288 ], [ %469, %468 ]
br i1 %22, label %433, label %468
433: ; preds = %431
%434 = getelementptr inbounds float*, float** %11, i64 %432
%435 = getelementptr inbounds float, float* %19, i64 %432
%436 = load float, float* %435
%437 = load float*, float** %434
br i1 %218, label %458, label %438
438: ; preds = %433, %438
%439 = phi float* [ %453, %438 ], [ %437, %433 ]
%440 = phi i64 [ %455, %438 ], [ 0, %433 ]
%441 = phi i64 [ %456, %438 ], [ 0, %433 ]
%442 = getelementptr inbounds float, float* %439, i64 %440
%443 = load float, float* %442
%444 = fdiv float %443, %436
%445 = tail call float @sqrtf(float %444)
%446 = load float*, float** %434
%447 = getelementptr inbounds float, float* %446, i64 %440
store float %445, float* %447
%448 = or i64 %440, 1
%449 = getelementptr inbounds float, float* %446, i64 %448
%450 = load float, float* %449
%451 = fdiv float %450, %436
%452 = tail call float @sqrtf(float %451)
%453 = load float*, float** %434
%454 = getelementptr inbounds float, float* %453, i64 %448
store float %452, float* %454
%455 = add nuw nsw i64 %440, 2
%456 = add i64 %441, 2
%457 = icmp eq i64 %456, %219
br i1 %457, label %458, label %438
458: ; preds = %438, %433
%459 = phi float* [ %437, %433 ], [ %453, %438 ]
%460 = phi i64 [ 0, %433 ], [ %455, %438 ]
br i1 %220, label %468, label %461
461: ; preds = %458
%462 = getelementptr inbounds float, float* %459, i64 %460
%463 = load float, float* %462
%464 = fdiv float %463, %436
%465 = tail call float @sqrtf(float %464)
%466 = load float*, float** %434
%467 = getelementptr inbounds float, float* %466, i64 %460
store float %465, float* %467
br label %468
468: ; preds = %461, %458, %431
%469 = add nuw nsw i64 %432, 1
%470 = icmp eq i64 %469, %289
br i1 %470, label %471, label %431
471: ; preds = %468, %287
%472 = tail call i32 (i32, float*, i32*, ...) bitcast (i32 (...)* @piksrt to i32 (i32, float*, i32*, ...)*)(i32 %247, float* %17, i32* %21)
%473 = sdiv i32 %247, 2
%474 = add nsw i32 %473, 1
%475 = add nsw i32 %474, %247
%476 = icmp sgt i32 %475, %3
%477 = sub nsw i32 %3, %247
%478 = select i1 %476, i32 %477, i32 %474
%479 = icmp sgt i32 %478, 0
br i1 %479, label %480, label %744
480: ; preds = %471
%481 = sext i32 %247 to i64
%482 = zext i32 %478 to i64
br label %483
483: ; preds = %480, %741
%484 = phi i64 [ 0, %480 ], [ %742, %741 ]
%485 = getelementptr inbounds i32, i32* %21, i64 %484
%486 = load i32, i32* %485
br i1 %22, label %487, label %741
487: ; preds = %483
%488 = sext i32 %486 to i64
%489 = getelementptr inbounds float*, float** %4, i64 %488
%490 = load float*, float** %489
%491 = getelementptr inbounds float*, float** %11, i64 %488
%492 = load float*, float** %491
%493 = add nsw i64 %484, %481
%494 = getelementptr inbounds float*, float** %4, i64 %493
%495 = load float*, float** %494
br i1 %221, label %573, label %496
496: ; preds = %487
%497 = getelementptr float, float* %495, i64 %202
%498 = getelementptr float, float* %490, i64 %202
%499 = getelementptr float, float* %492, i64 %202
%500 = icmp ult float* %495, %498
%501 = icmp ult float* %490, %497
%502 = and i1 %500, %501
%503 = icmp ult float* %495, %499
%504 = icmp ult float* %492, %497
%505 = and i1 %503, %504
%506 = or i1 %502, %505
br i1 %506, label %573, label %507
507: ; preds = %496
br i1 %224, label %551, label %508
508: ; preds = %507, %508
%509 = phi i64 [ %548, %508 ], [ 0, %507 ]
%510 = phi i64 [ %549, %508 ], [ 0, %507 ]
%511 = getelementptr inbounds float, float* %490, i64 %509
%512 = bitcast float* %511 to <4 x float>*
%513 = load <4 x float>, <4 x float>* %512
%514 = getelementptr inbounds float, float* %511, i64 4
%515 = bitcast float* %514 to <4 x float>*
%516 = load <4 x float>, <4 x float>* %515
%517 = getelementptr inbounds float, float* %492, i64 %509
%518 = bitcast float* %517 to <4 x float>*
%519 = load <4 x float>, <4 x float>* %518
%520 = getelementptr inbounds float, float* %517, i64 4
%521 = bitcast float* %520 to <4 x float>*
%522 = load <4 x float>, <4 x float>* %521
%523 = fsub <4 x float> %513, %519
%524 = fsub <4 x float> %516, %522
%525 = getelementptr inbounds float, float* %495, i64 %509
%526 = bitcast float* %525 to <4 x float>*
store <4 x float> %523, <4 x float>* %526
%527 = getelementptr inbounds float, float* %525, i64 4
%528 = bitcast float* %527 to <4 x float>*
store <4 x float> %524, <4 x float>* %528
%529 = or i64 %509, 8
%530 = getelementptr inbounds float, float* %490, i64 %529
%531 = bitcast float* %530 to <4 x float>*
%532 = load <4 x float>, <4 x float>* %531
%533 = getelementptr inbounds float, float* %530, i64 4
%534 = bitcast float* %533 to <4 x float>*
%535 = load <4 x float>, <4 x float>* %534
%536 = getelementptr inbounds float, float* %492, i64 %529
%537 = bitcast float* %536 to <4 x float>*
%538 = load <4 x float>, <4 x float>* %537
%539 = getelementptr inbounds float, float* %536, i64 4
%540 = bitcast float* %539 to <4 x float>*
%541 = load <4 x float>, <4 x float>* %540
%542 = fsub <4 x float> %532, %538
%543 = fsub <4 x float> %535, %541
%544 = getelementptr inbounds float, float* %495, i64 %529
%545 = bitcast float* %544 to <4 x float>*
store <4 x float> %542, <4 x float>* %545
%546 = getelementptr inbounds float, float* %544, i64 4
%547 = bitcast float* %546 to <4 x float>*
store <4 x float> %543, <4 x float>* %547
%548 = add nuw i64 %509, 16
%549 = add i64 %510, 2
%550 = icmp eq i64 %549, %225
br i1 %550, label %551, label %508
551: ; preds = %508, %507
%552 = phi i64 [ 0, %507 ], [ %548, %508 ]
br i1 %226, label %572, label %553
553: ; preds = %551
%554 = getelementptr inbounds float, float* %490, i64 %552
%555 = bitcast float* %554 to <4 x float>*
%556 = load <4 x float>, <4 x float>* %555
%557 = getelementptr inbounds float, float* %554, i64 4
%558 = bitcast float* %557 to <4 x float>*
%559 = load <4 x float>, <4 x float>* %558
%560 = getelementptr inbounds float, float* %492, i64 %552
%561 = bitcast float* %560 to <4 x float>*
%562 = load <4 x float>, <4 x float>* %561
%563 = getelementptr inbounds float, float* %560, i64 4
%564 = bitcast float* %563 to <4 x float>*
%565 = load <4 x float>, <4 x float>* %564
%566 = fsub <4 x float> %556, %562
%567 = fsub <4 x float> %559, %565
%568 = getelementptr inbounds float, float* %495, i64 %552
%569 = bitcast float* %568 to <4 x float>*
store <4 x float> %566, <4 x float>* %569
%570 = getelementptr inbounds float, float* %568, i64 4
%571 = bitcast float* %570 to <4 x float>*
store <4 x float> %567, <4 x float>* %571
br label %572
572: ; preds = %551, %553
br i1 %227, label %592, label %573
573: ; preds = %496, %487, %572
%574 = phi i64 [ 0, %496 ], [ 0, %487 ], [ %222, %572 ]
%575 = xor i64 %574, -1
%576 = add nsw i64 %202, %575
br i1 %229, label %589, label %577
577: ; preds = %573, %577
%578 = phi i64 [ %586, %577 ], [ %574, %573 ]
%579 = phi i64 [ %587, %577 ], [ 0, %573 ]
%580 = getelementptr inbounds float, float* %490, i64 %578
%581 = load float, float* %580
%582 = getelementptr inbounds float, float* %492, i64 %578
%583 = load float, float* %582
%584 = fsub float %581, %583
%585 = getelementptr inbounds float, float* %495, i64 %578
store float %584, float* %585
%586 = add nuw nsw i64 %578, 1
%587 = add i64 %579, 1
%588 = icmp eq i64 %587, %228
br i1 %588, label %589, label %577
589: ; preds = %577, %573
%590 = phi i64 [ %574, %573 ], [ %586, %577 ]
%591 = icmp ult i64 %576, 3
br i1 %591, label %592, label %683
592: ; preds = %589, %683, %572
br i1 %22, label %593, label %741
593: ; preds = %592
%594 = sext i32 %486 to i64
%595 = getelementptr inbounds float*, float** %4, i64 %594
%596 = load float*, float** %595
%597 = getelementptr inbounds float*, float** %11, i64 %594
%598 = load float*, float** %597
br i1 %230, label %665, label %599
599: ; preds = %593
%600 = getelementptr float, float* %596, i64 %202
%601 = getelementptr float, float* %598, i64 %202
%602 = icmp ult float* %596, %601
%603 = icmp ult float* %598, %600
%604 = and i1 %602, %603
br i1 %604, label %665, label %605
605: ; preds = %599
br i1 %233, label %645, label %606
606: ; preds = %605, %606
%607 = phi i64 [ %642, %606 ], [ 0, %605 ]
%608 = phi i64 [ %643, %606 ], [ 0, %605 ]
%609 = getelementptr inbounds float, float* %596, i64 %607
%610 = bitcast float* %609 to <4 x float>*
%611 = load <4 x float>, <4 x float>* %610
%612 = getelementptr inbounds float, float* %609, i64 4
%613 = bitcast float* %612 to <4 x float>*
%614 = load <4 x float>, <4 x float>* %613
%615 = getelementptr inbounds float, float* %598, i64 %607
%616 = bitcast float* %615 to <4 x float>*
%617 = load <4 x float>, <4 x float>* %616
%618 = getelementptr inbounds float, float* %615, i64 4
%619 = bitcast float* %618 to <4 x float>*
%620 = load <4 x float>, <4 x float>* %619
%621 = fadd <4 x float> %611, %617
%622 = fadd <4 x float> %614, %620
%623 = bitcast float* %609 to <4 x float>*
store <4 x float> %621, <4 x float>* %623
%624 = bitcast float* %612 to <4 x float>*
store <4 x float> %622, <4 x float>* %624
%625 = or i64 %607, 8
%626 = getelementptr inbounds float, float* %596, i64 %625
%627 = bitcast float* %626 to <4 x float>*
%628 = load <4 x float>, <4 x float>* %627
%629 = getelementptr inbounds float, float* %626, i64 4
%630 = bitcast float* %629 to <4 x float>*
%631 = load <4 x float>, <4 x float>* %630
%632 = getelementptr inbounds float, float* %598, i64 %625
%633 = bitcast float* %632 to <4 x float>*
%634 = load <4 x float>, <4 x float>* %633
%635 = getelementptr inbounds float, float* %632, i64 4
%636 = bitcast float* %635 to <4 x float>*
%637 = load <4 x float>, <4 x float>* %636
%638 = fadd <4 x float> %628, %634
%639 = fadd <4 x float> %631, %637
%640 = bitcast float* %626 to <4 x float>*
store <4 x float> %638, <4 x float>* %640
%641 = bitcast float* %629 to <4 x float>*
store <4 x float> %639, <4 x float>* %641
%642 = add nuw i64 %607, 16
%643 = add i64 %608, 2
%644 = icmp eq i64 %643, %234
br i1 %644, label %645, label %606
645: ; preds = %606, %605
%646 = phi i64 [ 0, %605 ], [ %642, %606 ]
br i1 %235, label %664, label %647
647: ; preds = %645
%648 = getelementptr inbounds float, float* %596, i64 %646
%649 = bitcast float* %648 to <4 x float>*
%650 = load <4 x float>, <4 x float>* %649
%651 = getelementptr inbounds float, float* %648, i64 4
%652 = bitcast float* %651 to <4 x float>*
%653 = load <4 x float>, <4 x float>* %652
%654 = getelementptr inbounds float, float* %598, i64 %646
%655 = bitcast float* %654 to <4 x float>*
%656 = load <4 x float>, <4 x float>* %655
%657 = getelementptr inbounds float, float* %654, i64 4
%658 = bitcast float* %657 to <4 x float>*
%659 = load <4 x float>, <4 x float>* %658
%660 = fadd <4 x float> %650, %656
%661 = fadd <4 x float> %653, %659
%662 = bitcast float* %648 to <4 x float>*
store <4 x float> %660, <4 x float>* %662
%663 = bitcast float* %651 to <4 x float>*
store <4 x float> %661, <4 x float>* %663
br label %664
664: ; preds = %645, %647
br i1 %236, label %741, label %665
665: ; preds = %599, %593, %664
%666 = phi i64 [ 0, %599 ], [ 0, %593 ], [ %231, %664 ]
%667 = xor i64 %666, -1
%668 = add nsw i64 %202, %667
br i1 %238, label %680, label %669
669: ; preds = %665, %669
%670 = phi i64 [ %677, %669 ], [ %666, %665 ]
%671 = phi i64 [ %678, %669 ], [ 0, %665 ]
%672 = getelementptr inbounds float, float* %596, i64 %670
%673 = load float, float* %672
%674 = getelementptr inbounds float, float* %598, i64 %670
%675 = load float, float* %674
%676 = fadd float %673, %675
store float %676, float* %672
%677 = add nuw nsw i64 %670, 1
%678 = add i64 %671, 1
%679 = icmp eq i64 %678, %237
br i1 %679, label %680, label %669
680: ; preds = %669, %665
%681 = phi i64 [ %666, %665 ], [ %677, %669 ]
%682 = icmp ult i64 %668, 3
br i1 %682, label %741, label %714
683: ; preds = %589, %683
%684 = phi i64 [ %712, %683 ], [ %590, %589 ]
%685 = getelementptr inbounds float, float* %490, i64 %684
%686 = load float, float* %685
%687 = getelementptr inbounds float, float* %492, i64 %684
%688 = load float, float* %687
%689 = fsub float %686, %688
%690 = getelementptr inbounds float, float* %495, i64 %684
store float %689, float* %690
%691 = add nuw nsw i64 %684, 1
%692 = getelementptr inbounds float, float* %490, i64 %691
%693 = load float, float* %692
%694 = getelementptr inbounds float, float* %492, i64 %691
%695 = load float, float* %694
%696 = fsub float %693, %695
%697 = getelementptr inbounds float, float* %495, i64 %691
store float %696, float* %697
%698 = add nuw nsw i64 %684, 2
%699 = getelementptr inbounds float, float* %490, i64 %698
%700 = load float, float* %699
%701 = getelementptr inbounds float, float* %492, i64 %698
%702 = load float, float* %701
%703 = fsub float %700, %702
%704 = getelementptr inbounds float, float* %495, i64 %698
store float %703, float* %704
%705 = add nuw nsw i64 %684, 3
%706 = getelementptr inbounds float, float* %490, i64 %705
%707 = load float, float* %706
%708 = getelementptr inbounds float, float* %492, i64 %705
%709 = load float, float* %708
%710 = fsub float %707, %709
%711 = getelementptr inbounds float, float* %495, i64 %705
store float %710, float* %711
%712 = add nuw nsw i64 %684, 4
%713 = icmp eq i64 %712, %202
br i1 %713, label %592, label %683
714: ; preds = %680, %714
%715 = phi i64 [ %739, %714 ], [ %681, %680 ]
%716 = getelementptr inbounds float, float* %596, i64 %715
%717 = load float, float* %716
%718 = getelementptr inbounds float, float* %598, i64 %715
%719 = load float, float* %718
%720 = fadd float %717, %719
store float %720, float* %716
%721 = add nuw nsw i64 %715, 1
%722 = getelementptr inbounds float, float* %596, i64 %721
%723 = load float, float* %722
%724 = getelementptr inbounds float, float* %598, i64 %721
%725 = load float, float* %724
%726 = fadd float %723, %725
store float %726, float* %722
%727 = add nuw nsw i64 %715, 2
%728 = getelementptr inbounds float, float* %596, i64 %727
%729 = load float, float* %728
%730 = getelementptr inbounds float, float* %598, i64 %727
%731 = load float, float* %730
%732 = fadd float %729, %731
store float %732, float* %728
%733 = add nuw nsw i64 %715, 3
%734 = getelementptr inbounds float, float* %596, i64 %733
%735 = load float, float* %734
%736 = getelementptr inbounds float, float* %598, i64 %733
%737 = load float, float* %736
%738 = fadd float %735, %737
store float %738, float* %734
%739 = add nuw nsw i64 %715, 4
%740 = icmp eq i64 %739, %202
br i1 %740, label %741, label %714
741: ; preds = %680, %714, %664, %483, %592
%742 = add nuw nsw i64 %484, 1
%743 = icmp ult i64 %742, %482
br i1 %743, label %483, label %744
744: ; preds = %741, %471
%745 = add nsw i32 %478, %247
%746 = tail call i32 (float*, i32, i32, i32, float**, double, i8*, float*, ...) bitcast (i32 (...)* @gla to i32 (float*, i32, i32, i32, float**, double, i8*, float*, ...)*)(float* %0, i32 %1, i32 %2, i32 %745, float** %4, double %203, i8* %6, float* %7)
%747 = icmp eq i32 %746, 0
br i1 %747, label %246, label %748
748: ; preds = %744
%749 = icmp sgt i32 %745, 1
br i1 %749, label %750, label %913
750: ; preds = %748
%751 = icmp ult i64 %202, 8
%752 = and i64 %202, 4294967288
%753 = and i64 %209, 3
%754 = icmp ult i64 %207, 24
%755 = and i64 %209, 4611686018427387900
%756 = icmp eq i64 %753, 0
%757 = icmp eq i64 %202, %752
%758 = and i64 %202, 3
%759 = icmp eq i64 %758, 0
br label %766
760: ; preds = %908, %766
%761 = phi i32 [ %769, %766 ], [ %909, %908 ]
%762 = add nsw i32 %761, -1
%763 = sext i32 %762 to i64
%764 = icmp slt i64 %770, %763
%765 = add nuw nsw i64 %768, 1
br i1 %764, label %766, label %913
766: ; preds = %750, %760
%767 = phi i64 [ %770, %760 ], [ 0, %750 ]
%768 = phi i64 [ %765, %760 ], [ 1, %750 ]
%769 = phi i32 [ %761, %760 ], [ %745, %750 ]
%770 = add nuw nsw i64 %767, 1
%771 = sext i32 %769 to i64
%772 = icmp slt i64 %770, %771
br i1 %772, label %773, label %760
773: ; preds = %766
%774 = getelementptr inbounds float*, float** %4, i64 %767
br label %775
775: ; preds = %773, %908
%776 = phi i64 [ %768, %773 ], [ %910, %908 ]
%777 = phi i32 [ %769, %773 ], [ %909, %908 ]
%778 = load float*, float** %774
%779 = getelementptr inbounds float*, float** %4, i64 %776
%780 = load float*, float** %779
%781 = tail call i32 (float*, float*, i32, ...) bitcast (i32 (...)* @distance2 to i32 (float*, float*, i32, ...)*)(float* %778, float* %780, i32 %2)
%782 = icmp eq i32 %781, 0
br i1 %782, label %783, label %908
783: ; preds = %775
%784 = add nsw i32 %777, -1
%785 = sext i32 %784 to i64
%786 = icmp slt i64 %776, %785
br i1 %786, label %787, label %908
787: ; preds = %783, %905
%788 = phi i64 [ %789, %905 ], [ %776, %783 ]
%789 = add nuw nsw i64 %788, 1
br i1 %22, label %790, label %905
790: ; preds = %787
%791 = getelementptr inbounds float*, float** %4, i64 %789
%792 = load float*, float** %791
%793 = getelementptr inbounds float*, float** %4, i64 %788
%794 = load float*, float** %793
br i1 %751, label %870, label %795
795: ; preds = %790
%796 = getelementptr float, float* %794, i64 %202
%797 = getelementptr float, float* %792, i64 %202
%798 = icmp ult float* %794, %797
%799 = icmp ult float* %792, %796
%800 = and i1 %798, %799
br i1 %800, label %870, label %801
801: ; preds = %795
br i1 %754, label %851, label %802
802: ; preds = %801, %802
%803 = phi i64 [ %848, %802 ], [ 0, %801 ]
%804 = phi i64 [ %849, %802 ], [ 0, %801 ]
%805 = getelementptr inbounds float, float* %792, i64 %803
%806 = bitcast float* %805 to <4 x float>*
%807 = load <4 x float>, <4 x float>* %806
%808 = getelementptr inbounds float, float* %805, i64 4
%809 = bitcast float* %808 to <4 x float>*
%810 = load <4 x float>, <4 x float>* %809
%811 = getelementptr inbounds float, float* %794, i64 %803
%812 = bitcast float* %811 to <4 x float>*
store <4 x float> %807, <4 x float>* %812
%813 = getelementptr inbounds float, float* %811, i64 4
%814 = bitcast float* %813 to <4 x float>*
store <4 x float> %810, <4 x float>* %814
%815 = or i64 %803, 8
%816 = getelementptr inbounds float, float* %792, i64 %815
%817 = bitcast float* %816 to <4 x float>*
%818 = load <4 x float>, <4 x float>* %817
%819 = getelementptr inbounds float, float* %816, i64 4
%820 = bitcast float* %819 to <4 x float>*
%821 = load <4 x float>, <4 x float>* %820
%822 = getelementptr inbounds float, float* %794, i64 %815
%823 = bitcast float* %822 to <4 x float>*
store <4 x float> %818, <4 x float>* %823
%824 = getelementptr inbounds float, float* %822, i64 4
%825 = bitcast float* %824 to <4 x float>*
store <4 x float> %821, <4 x float>* %825
%826 = or i64 %803, 16
%827 = getelementptr inbounds float, float* %792, i64 %826
%828 = bitcast float* %827 to <4 x float>*
%829 = load <4 x float>, <4 x float>* %828
%830 = getelementptr inbounds float, float* %827, i64 4
%831 = bitcast float* %830 to <4 x float>*
%832 = load <4 x float>, <4 x float>* %831
%833 = getelementptr inbounds float, float* %794, i64 %826
%834 = bitcast float* %833 to <4 x float>*
store <4 x float> %829, <4 x float>* %834
%835 = getelementptr inbounds float, float* %833, i64 4
%836 = bitcast float* %835 to <4 x float>*
store <4 x float> %832, <4 x float>* %836
%837 = or i64 %803, 24
%838 = getelementptr inbounds float, float* %792, i64 %837
%839 = bitcast float* %838 to <4 x float>*
%840 = load <4 x float>, <4 x float>* %839
%841 = getelementptr inbounds float, float* %838, i64 4
%842 = bitcast float* %841 to <4 x float>*
%843 = load <4 x float>, <4 x float>* %842
%844 = getelementptr inbounds float, float* %794, i64 %837
%845 = bitcast float* %844 to <4 x float>*
store <4 x float> %840, <4 x float>* %845
%846 = getelementptr inbounds float, float* %844, i64 4
%847 = bitcast float* %846 to <4 x float>*
store <4 x float> %843, <4 x float>* %847
%848 = add nuw i64 %803, 32
%849 = add i64 %804, 4
%850 = icmp eq i64 %849, %755
br i1 %850, label %851, label %802
851: ; preds = %802, %801
%852 = phi i64 [ 0, %801 ], [ %848, %802 ]
br i1 %756, label %869, label %853
853: ; preds = %851, %853
%854 = phi i64 [ %866, %853 ], [ %852, %851 ]
%855 = phi i64 [ %867, %853 ], [ 0, %851 ]
%856 = getelementptr inbounds float, float* %792, i64 %854
%857 = bitcast float* %856 to <4 x float>*
%858 = load <4 x float>, <4 x float>* %857
%859 = getelementptr inbounds float, float* %856, i64 4
%860 = bitcast float* %859 to <4 x float>*
%861 = load <4 x float>, <4 x float>* %860
%862 = getelementptr inbounds float, float* %794, i64 %854
%863 = bitcast float* %862 to <4 x float>*
store <4 x float> %858, <4 x float>* %863
%864 = getelementptr inbounds float, float* %862, i64 4
%865 = bitcast float* %864 to <4 x float>*
store <4 x float> %861, <4 x float>* %865
%866 = add nuw i64 %854, 8
%867 = add i64 %855, 1
%868 = icmp eq i64 %867, %753
br i1 %868, label %869, label %853
869: ; preds = %853, %851
br i1 %757, label %905, label %870
870: ; preds = %795, %790, %869
%871 = phi i64 [ 0, %795 ], [ 0, %790 ], [ %752, %869 ]
%872 = xor i64 %871, -1
%873 = add nsw i64 %202, %872
br i1 %759, label %883, label %874
874: ; preds = %870, %874
%875 = phi i64 [ %880, %874 ], [ %871, %870 ]
%876 = phi i64 [ %881, %874 ], [ 0, %870 ]
%877 = getelementptr inbounds float, float* %792, i64 %875
%878 = load float, float* %877
%879 = getelementptr inbounds float, float* %794, i64 %875
store float %878, float* %879
%880 = add nuw nsw i64 %875, 1
%881 = add i64 %876, 1
%882 = icmp eq i64 %881, %758
br i1 %882, label %883, label %874
883: ; preds = %874, %870
%884 = phi i64 [ %871, %870 ], [ %880, %874 ]
%885 = icmp ult i64 %873, 3
br i1 %885, label %905, label %886
886: ; preds = %883, %886
%887 = phi i64 [ %903, %886 ], [ %884, %883 ]
%888 = getelementptr inbounds float, float* %792, i64 %887
%889 = load float, float* %888
%890 = getelementptr inbounds float, float* %794, i64 %887
store float %889, float* %890
%891 = add nuw nsw i64 %887, 1
%892 = getelementptr inbounds float, float* %792, i64 %891
%893 = load float, float* %892
%894 = getelementptr inbounds float, float* %794, i64 %891
store float %893, float* %894
%895 = add nuw nsw i64 %887, 2
%896 = getelementptr inbounds float, float* %792, i64 %895
%897 = load float, float* %896
%898 = getelementptr inbounds float, float* %794, i64 %895
store float %897, float* %898
%899 = add nuw nsw i64 %887, 3
%900 = getelementptr inbounds float, float* %792, i64 %899
%901 = load float, float* %900
%902 = getelementptr inbounds float, float* %794, i64 %899
store float %901, float* %902
%903 = add nuw nsw i64 %887, 4
%904 = icmp eq i64 %903, %202
br i1 %904, label %905, label %886
905: ; preds = %883, %886, %869, %787
%906 = trunc i64 %789 to i32
%907 = icmp sgt i32 %784, %906
br i1 %907, label %787, label %908
908: ; preds = %905, %783, %775
%909 = phi i32 [ %777, %775 ], [ %784, %783 ], [ %784, %905 ]
%910 = add nuw nsw i64 %776, 1
%911 = trunc i64 %910 to i32
%912 = icmp sgt i32 %909, %911
br i1 %912, label %775, label %760
913: ; preds = %246, %760, %748
%914 = phi i32 [ %745, %748 ], [ %761, %760 ], [ %247, %246 ]
%915 = tail call i32 (float**, i32, ...) bitcast (i32 (...)* @free_fmatrix to i32 (float**, i32, ...)*)(float** %11, i32 %3)
tail call void @free(i8* %13)
tail call void @free(i8* %20)
tail call void @free(i8* %16)
tail call void @free(i8* %18)
ret i32 %914
}