int minvf(float *a, int n) {
  static int *sle = 0;
  static float *sq0 = 0;
  static int rsize = 0;
  int lc, *le;
  float s, t, tq = 0., zr = 1.e-15;
  float *pa, *pd, *ps, *p, *q, *q0;
  int i, j, k, m;
  if (rsize < n) {
    if (sle)
      MemFree(sle);
    if (sq0)
      MemFree(sq0);
    rsize = n;
    sle = (int *)MemAlloc(rsize * sizeof(int));
    sq0 = (float *)MemAlloc(rsize * sizeof(float));
  }
  le = sle;
  q0 = sq0;
  for (j = 0, pa = pd = a; j < n; ++j, ++pa, pd += n + 1) {
    if (j > 0) {
      for (i = 0, q = q0, p = pa; i < n; ++i, p += n)
        *q++ = *p;
      for (i = 1; i < n; ++i) {
        lc = i < j ? i : j;
        for (k = 0, p = pa + i * n - j, q = q0, t = 0.; k < lc; ++k)
          t += *p++ * *q++;
        q0[i] -= t;
      }
      for (i = 0, q = q0, p = pa; i < n; ++i, p += n)
        *p = *q++;
    }
    s = fabs(*pd);
    lc = j;
    for (k = j + 1, ps = pd; k < n; ++k) {
      if ((t = fabs(*(ps += n))) > s) {
        s = t;
        lc = k;
      }
    }
    tq = tq > s ? tq : s;
    if (s < zr * tq) {
      return -1;
    }
    *le++ = lc;
    if (lc != j) {
      for (k = 0, p = a + n * j, q = a + n * lc; k < n; ++k) {
        t = *p;
        *p++ = *q;
        *q++ = t;
      }
    }
    for (k = j + 1, ps = pd, t = 1. / *pd; k < n; ++k)
      *(ps += n) *= t;
    *pd = t;
  }
  for (j = 1, pd = ps = a; j < n; ++j) {
    for (k = 0, pd += n + 1, q = ++ps; k < j; ++k, q += n)
      *q *= *pd;
  }
  for (j = 1, pa = a; j < n; ++j) {
    ++pa;
    for (i = 0, q = q0, p = pa; i < j; ++i, p += n)
      *q++ = *p;
    for (k = 0; k < j; ++k) {
      t = 0.;
      for (i = k, p = pa + k * n + k - j, q = q0 + k; i < j; ++i)
        t -= *p++ * *q++;
      q0[k] = t;
    }
    for (i = 0, q = q0, p = pa; i < j; ++i, p += n)
      *p = *q++;
  }
  for (j = n - 2, pd = pa = a + n * n - 1; j >= 0; --j) {
    --pa;
    pd -= n + 1;
    for (i = 0, m = n - j - 1, q = q0, p = pd + n; i < m; ++i, p += n)
      *q++ = *p;
    for (k = n - 1, ps = pa; k > j; --k, ps -= n) {
      t = -(*ps);
      for (i = j + 1, p = ps, q = q0; i < k; ++i)
        t -= *++p * *q++;
      q0[--m] = t;
    }
    for (i = 0, m = n - j - 1, q = q0, p = pd + n; i < m; ++i, p += n)
      *p = *q++;
  }
  for (k = 0, pa = a; k < n - 1; ++k, ++pa) {
    for (i = 0, q = q0, p = pa; i < n; ++i, p += n)
      *q++ = *p;
    for (j = 0, ps = a; j < n; ++j, ps += n) {
      if (j > k) {
        t = 0.;
        p = ps + j;
        i = j;
      } else {
        t = q0[j];
        p = ps + k + 1;
        i = k + 1;
      }
      for (; i < n;)
        t += *p++ * q0[i++];
      q0[j] = t;
    }
    for (i = 0, q = q0, p = pa; i < n; ++i, p += n)
      *p = *q++;
  }
  for (j = n - 2, le--; j >= 0; --j) {
    for (k = 0, p = a + j, q = a + *(--le); k < n; ++k, p += n, q += n) {
      t = *p;
      *p = *q;
      *q = t;
    }
  }
  return 0;
}


x86 assembly (clang, -O0):
<minvf>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  0xebe(%rip),%xmm0
movss  %xmm0,-0x30(%rbp)
mov    0x2efb(%rip),%eax
cmp    -0x14(%rbp),%eax
jge    11cd <minvf+0xad>
cmpq   $0x0,0x2eda(%rip)
je     1172 <minvf+0x52>
mov    0x2ecd(%rip),%rdi
mov    $0x0,%al
call   1030 <MemFree@plt>
cmpq   $0x0,0x2ec6(%rip)
je     118e <minvf+0x6e>
mov    0x2eb9(%rip),%rdi
mov    $0x0,%al
call   1030 <MemFree@plt>
mov    -0x14(%rbp),%eax
mov    %eax,0x2eb1(%rip)
movslq 0x2eaa(%rip),%rdi
shl    $0x2,%rdi
mov    $0x0,%al
call   1040 <MemAlloc@plt>
cltq
mov    %rax,0x2e86(%rip)
movslq 0x2e8f(%rip),%rdi
shl    $0x2,%rdi
mov    $0x0,%al
call   1040 <MemAlloc@plt>
cltq
mov    %rax,0x2e73(%rip)
mov    0x2e64(%rip),%rax
mov    %rax,-0x20(%rbp)
mov    0x2e61(%rip),%rax
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    %rax,-0x38(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    162f <minvf+0x50f>
cmpl   $0x0,-0x68(%rbp)
jle    13c4 <minvf+0x2a4>
movl   $0x0,-0x64(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    126d <minvf+0x14d>
mov    -0x50(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  %xmm0,(%rax)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    1223 <minvf+0x103>
movl   $0x1,-0x64(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    135e <minvf+0x23e>
mov    -0x64(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    1297 <minvf+0x177>
mov    -0x64(%rbp),%eax
mov    %eax,-0x74(%rbp)
jmp    129d <minvf+0x17d>
mov    -0x68(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x74(%rbp),%eax
mov    %eax,-0x18(%rbp)
movl   $0x0,-0x6c(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x64(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x68(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x58(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x18(%rbp),%eax
jge    1335 <minvf+0x215>
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x50(%rbp)
movss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  (%rax),%xmm2
movss  -0x28(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    12e3 <minvf+0x1c3>
movss  -0x28(%rbp),%xmm1
mov    -0x60(%rbp),%rax
movslq -0x64(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1274 <minvf+0x154>
movl   $0x0,-0x64(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    13bf <minvf+0x29f>
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  (%rax),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    1375 <minvf+0x255>
jmp    13c4 <minvf+0x2a4>
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0xc39(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    146c <minvf+0x34c>
mov    -0x14(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
mov    %rcx,%rsi
shl    $0x2,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
mov    %rdx,-0x48(%rbp)
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
movaps 0xbde(%rip),%xmm1
pand   %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
ucomiss -0x24(%rbp),%xmm0
jbe    1459 <minvf+0x339>
movss  -0x28(%rbp),%xmm0
movss  %xmm0,-0x24(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    145e <minvf+0x33e>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    13fb <minvf+0x2db>
movss  -0x2c(%rbp),%xmm0
ucomiss -0x24(%rbp),%xmm0
jbe    148a <minvf+0x36a>
movss  -0x2c(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
jmp    1494 <minvf+0x374>
movss  -0x24(%rbp),%xmm0
movss  %xmm0,-0x78(%rbp)
movss  -0x78(%rbp),%xmm0
movss  %xmm0,-0x2c(%rbp)
movss  -0x24(%rbp),%xmm1
movss  -0x30(%rbp),%xmm0
mulss  -0x2c(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    14c2 <minvf+0x3a2>
movl   $0xffffffff,-0x4(%rbp)
jmp    1df2 <minvf+0xcd2>
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %rax,%rdx
add    $0x4,%rdx
mov    %rdx,-0x20(%rbp)
mov    %ecx,(%rax)
mov    -0x18(%rbp),%eax
cmp    -0x68(%rbp),%eax
je     157a <minvf+0x45a>
movl   $0x0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x68(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x18(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1575 <minvf+0x455>
mov    -0x50(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x50(%rbp)
movss  %xmm0,(%rax)
movss  -0x28(%rbp),%xmm0
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  %xmm0,(%rax)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    151b <minvf+0x3fb>
jmp    157a <minvf+0x45a>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x40(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xa81(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15f0 <minvf+0x4d0>
movss  -0x28(%rbp),%xmm0
mov    -0x14(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
mov    %rcx,%rsi
shl    $0x2,%rsi
mov    %rax,%rdx
add    %rsi,%rdx
mov    %rdx,-0x48(%rbp)
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    15ac <minvf+0x48c>
movss  -0x28(%rbp),%xmm0
mov    -0x40(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x38(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
jmp    11f6 <minvf+0xd6>
movl   $0x1,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    %rax,-0x40(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    16d3 <minvf+0x5b3>
movl   $0x0,-0x6c(%rbp)
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x48(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x48(%rbp)
mov    %rax,-0x58(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    16c0 <minvf+0x5a0>
mov    -0x40(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
mulss  (%rax),%xmm0
movss  %xmm0,(%rax)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
jmp    167d <minvf+0x55d>
jmp    16c5 <minvf+0x5a5>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    1642 <minvf+0x522>
movl   $0x1,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    18b6 <minvf+0x796>
mov    -0x38(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    175b <minvf+0x63b>
mov    -0x50(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  %xmm0,(%rax)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    1711 <minvf+0x5f1>
movl   $0x0,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    1842 <minvf+0x722>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x38(%rbp),%rax
mov    -0x6c(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x6c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x68(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x60(%rbp),%rax
movslq -0x6c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    1822 <minvf+0x702>
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x50(%rbp)
movss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  (%rax),%xmm2
movss  -0x28(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    17c3 <minvf+0x6a3>
movss  -0x28(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x6c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    1762 <minvf+0x642>
movl   $0x0,-0x64(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x68(%rbp),%eax
jge    18a3 <minvf+0x783>
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  (%rax),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    1859 <minvf+0x739>
jmp    18a8 <minvf+0x788>
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
jmp    16e2 <minvf+0x5c2>
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x14(%rbp),%ecx
imul   -0x14(%rbp),%ecx
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x38(%rbp)
mov    %rax,-0x40(%rbp)
cmpl   $0x0,-0x68(%rbp)
jl     1b08 <minvf+0x9e8>
mov    -0x38(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%ecx
add    $0x1,%ecx
mov    -0x40(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x14(%rbp),%eax
sub    -0x68(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x70(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    198b <minvf+0x86b>
mov    -0x50(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  %xmm0,(%rax)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    1941 <minvf+0x821>
mov    -0x14(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x68(%rbp),%eax
jle    1a7d <minvf+0x95d>
mov    -0x48(%rbp),%rax
movss  (%rax),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jge    1a3b <minvf+0x91b>
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x50(%rbp)
movss  0x4(%rax),%xmm0
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  (%rax),%xmm2
movss  -0x28(%rbp),%xmm1
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    19db <minvf+0x8bb>
movss  -0x28(%rbp),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x70(%rbp),%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x70(%rbp)
movslq %ecx,%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x6c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    199c <minvf+0x87c>
movl   $0x0,-0x64(%rbp)
mov    -0x14(%rbp),%eax
sub    -0x68(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x70(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x40(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x70(%rbp),%eax
jge    1af5 <minvf+0x9d5>
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  (%rax),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    1aab <minvf+0x98b>
jmp    1afa <minvf+0x9da>
mov    -0x68(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x68(%rbp)
jmp    18e0 <minvf+0x7c0>
movl   $0x0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x6c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    1d0f <minvf+0xbef>
movl   $0x0,-0x64(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1b89 <minvf+0xa69>
mov    -0x50(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  %xmm0,(%rax)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    1b3f <minvf+0xa1f>
movl   $0x0,-0x68(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x68(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1c8f <minvf+0xb6f>
mov    -0x68(%rbp),%eax
cmp    -0x6c(%rbp),%eax
jle    1bd6 <minvf+0xab6>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x68(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x64(%rbp)
jmp    1c08 <minvf+0xae8>
mov    -0x60(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x48(%rbp),%rax
movslq -0x6c(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
add    $0x4,%rax
mov    %rax,-0x50(%rbp)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1c0d <minvf+0xaed>
mov    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1c5a <minvf+0xb3a>
mov    -0x50(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x50(%rbp)
movss  (%rax),%xmm0
mov    -0x60(%rbp),%rax
mov    -0x64(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x64(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm2
movss  -0x28(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x28(%rbp)
jmp    1c0d <minvf+0xaed>
movss  -0x28(%rbp),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x68(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x68(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x68(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x48(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    1b98 <minvf+0xa78>
movl   $0x0,-0x64(%rbp)
mov    -0x60(%rbp),%rax
mov    %rax,-0x58(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x64(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1cf0 <minvf+0xbd0>
mov    -0x58(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x58(%rbp)
movss  (%rax),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    1ca6 <minvf+0xb86>
jmp    1cf5 <minvf+0xbd5>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x38(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x38(%rbp)
jmp    1b17 <minvf+0x9f7>
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
mov    %eax,-0x68(%rbp)
mov    -0x20(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x20(%rbp)
cmpl   $0x0,-0x68(%rbp)
jl     1deb <minvf+0xccb>
movl   $0x0,-0x6c(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x68(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x20(%rbp),%rcx
mov    %rcx,%rdx
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x20(%rbp)
movslq -0x4(%rcx),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
mov    -0x6c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    1dd8 <minvf+0xcb8>
mov    -0x50(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,-0x28(%rbp)
mov    -0x58(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x50(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x28(%rbp),%xmm0
mov    -0x58(%rbp),%rax
movss  %xmm0,(%rax)
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x50(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x14(%rbp),%ecx
mov    -0x58(%rbp),%rax
movslq %ecx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x58(%rbp)
jmp    1d6a <minvf+0xc4a>
jmp    1ddd <minvf+0xcbd>
mov    -0x68(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x68(%rbp)
jmp    1d24 <minvf+0xc04>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<minvf>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xc8,%rsp
mov    %esi,%r15d
mov    %rdi,0x20(%rsp)
cmp    %esi,0x3f09(%rip)
jge    11ab <minvf+0x8b>
mov    0x3ef0(%rip),%rdi
test   %rdi,%rdi
je     1154 <minvf+0x34>
xor    %eax,%eax
call   1030 <MemFree@plt>
mov    0x3ee5(%rip),%rdi
test   %rdi,%rdi
je     1167 <minvf+0x47>
xor    %eax,%eax
call   1030 <MemFree@plt>
mov    %r15d,0x3eda(%rip)
movslq %r15d,%rdi
shl    $0x2,%rdi
xor    %eax,%eax
call   1040 <MemAlloc@plt>
cltq
mov    %rax,0x3eb3(%rip)
movslq 0x3ebc(%rip),%rdi
shl    $0x2,%rdi
xor    %eax,%eax
call   1040 <MemAlloc@plt>
movslq %eax,%r13
mov    %r13,0x3e9f(%rip)
test   %r15d,%r15d
jg     11bb <minvf+0x9b>
jmp    2763 <minvf+0x1643>
mov    0x3e8e(%rip),%r13
test   %r15d,%r15d
jle    2763 <minvf+0x1643>
mov    0x3e76(%rip),%rdx
mov    %r15d,%esi
lea    -0x1(%r15),%ecx
mov    0x20(%rsp),%rax
lea    (%rax,%rcx,4),%rdi
add    $0x4,%rdi
mov    %rdi,0x78(%rsp)
mov    %rcx,0x30(%rsp)
lea    0x1(%rcx),%rdi
lea    -0x2(%r15),%ecx
mov    %ecx,0x44(%rsp)
mov    %rdi,0x80(%rsp)
and    $0xfffffffffffffff8,%rdi
mov    %rdi,0x60(%rsp)
lea    -0x8(%rdi),%rcx
mov    %rcx,0x70(%rsp)
mov    %rcx,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %r15d,%ecx
and    $0xfffffff8,%ecx
mov    %ecx,0x88(%rsp)
mov    %rdi,%rcx
mov    %rdi,0xa8(%rsp)
and    $0xfffffffffffffffe,%rdi
mov    %rdi,0xa0(%rsp)
mov    %rsi,%rcx
shl    $0x5,%rcx
mov    %rcx,0x50(%rsp)
lea    0x0(,%rsi,4),%rcx
mov    %r15d,%ebp
and    $0x7,%ebp
mov    %rsi,%rbx
shl    $0x4,%rbx
xorps  %xmm0,%xmm0
movaps 0x1da0(%rip),%xmm1
movss  0x1db8(%rip),%xmm2
movss  0x1db4(%rip),%xmm3
lea    (%rax,%rsi,4),%rdi
mov    %rdi,0xb0(%rsp)
lea    0x0(,%rsi,8),%r8
lea    0x30(%rax),%r11
mov    %rsi,0x8(%rsp)
lea    0x4(,%rsi,4),%rsi
mov    %rsi,0x90(%rsp)
lea    0x3(%r15),%r10d
lea    (%rcx,%rcx,2),%rsi
xor    %r9d,%r9d
mov    %rax,(%rsp)
mov    %r11,0xc0(%rsp)
xor    %r14d,%r14d
mov    %rax,0x10(%rsp)
mov    %r15,0x48(%rsp)
mov    %rbx,0x38(%rsp)
mov    %rbp,0x68(%rsp)
mov    %rsi,0x98(%rsp)
jmp    131a <minvf+0x1fa>
cs nopw 0x0(%rax,%rax,1)
nop
lea    0x4(%r12),%rdx
mov    (%rsp),%rax
movss  %xmm5,(%rax)
addq   $0x4,0x10(%rsp)
add    0x90(%rsp),%rax
mov    %rax,(%rsp)
add    $0x1,%r9d
add    %rcx,%r11
add    $0x3,%r10b
mov    0x18(%rsp),%r14
cmp    0x8(%rsp),%r14
je     1a46 <minvf+0x926>
mov    %rdx,%r12
test   %r14,%r14
mov    %rdx,0xb8(%rsp)
mov    %r10,0x58(%rsp)
je     14c4 <minvf+0x3a4>
mov    %r13,%rax
mov    0x10(%rsp),%rsi
mov    %rsi,%rdx
mov    0x88(%rsp),%edi
cmpl   $0x7,0x30(%rsp)
jb     13c7 <minvf+0x2a7>
mov    %rsi,%rdx
movss  (%rsi),%xmm4
movss  %xmm4,(%rax)
add    %rcx,%rsi
movss  (%rdx,%rcx,1),%xmm4
movss  %xmm4,0x4(%rax)
movss  (%rcx,%rsi,1),%xmm4
add    %rcx,%rsi
movss  %xmm4,0x8(%rax)
movss  (%rcx,%rsi,1),%xmm4
add    %rcx,%rsi
movss  %xmm4,0xc(%rax)
movss  (%rcx,%rsi,1),%xmm4
add    %rcx,%rsi
movss  %xmm4,0x10(%rax)
movss  (%rcx,%rsi,1),%xmm4
add    %rcx,%rsi
movss  %xmm4,0x14(%rax)
movss  (%rcx,%rsi,1),%xmm4
add    %rcx,%rsi
movss  %xmm4,0x18(%rax)
movss  (%rcx,%rsi,1),%xmm4
add    %rcx,%rsi
movss  %xmm4,0x1c(%rax)
add    $0x20,%rax
add    %rcx,%rsi
add    $0xfffffff8,%edi
jne    1350 <minvf+0x230>
add    0x50(%rsp),%rdx
test   $0x7,%r15b
je     13e4 <minvf+0x2c4>
xor    %esi,%esi
nop
movss  (%rdx),%xmm4
movss  %xmm4,(%rax,%rsi,4)
add    $0x1,%rsi
add    %rcx,%rdx
cmp    %esi,%ebp
jne    13d0 <minvf+0x2b0>
cmp    $0x1,%r15d
jne    1530 <minvf+0x410>
mov    %r13,%rax
mov    0x10(%rsp),%rdx
cmpl   $0x7,0x30(%rsp)
mov    0x48(%rsp),%r15
mov    0xb8(%rsp),%r12
mov    0x38(%rsp),%rbx
mov    0x68(%rsp),%rbp
mov    0x58(%rsp),%r10
jb     14a7 <minvf+0x387>
mov    0x88(%rsp),%esi
mov    0x10(%rsp),%rdi
mov    %r13,%rax
nopl   0x0(%rax)
mov    %rdi,%rdx
movss  (%rax),%xmm4
movss  %xmm4,(%rdi)
movss  0x4(%rax),%xmm4
add    %rcx,%rdi
movss  %xmm4,(%rdx,%rcx,1)
movss  0x8(%rax),%xmm4
movss  %xmm4,(%rcx,%rdi,1)
add    %rcx,%rdi
movss  0xc(%rax),%xmm4
movss  %xmm4,(%rcx,%rdi,1)
add    %rcx,%rdi
movss  0x10(%rax),%xmm4
movss  %xmm4,(%rcx,%rdi,1)
add    %rcx,%rdi
movss  0x14(%rax),%xmm4
movss  %xmm4,(%rcx,%rdi,1)
add    %rcx,%rdi
movss  0x18(%rax),%xmm4
movss  %xmm4,(%rcx,%rdi,1)
add    %rcx,%rdi
movss  0x1c(%rax),%xmm4
add    $0x20,%rax
movss  %xmm4,(%rcx,%rdi,1)
add    %rcx,%rdi
add    %rcx,%rdi
add    $0xfffffff8,%esi
jne    1430 <minvf+0x310>
add    0x50(%rsp),%rdx
test   $0x7,%r15b
je     14c4 <minvf+0x3a4>
xor    %esi,%esi
nop
movss  (%rax,%rsi,4),%xmm4
movss  %xmm4,(%rdx)
add    $0x1,%rsi
add    %rcx,%rdx
cmp    %esi,%ebp
jne    14b0 <minvf+0x390>
mov    0x30(%rsp),%rax
mov    %eax,%edx
sub    %r14d,%edx
mov    (%rsp),%rax
movss  (%rax),%xmm4
movaps %xmm4,%xmm6
andps  %xmm1,%xmm6
lea    0x1(%r14),%rsi
cmp    0x8(%rsp),%rsi
mov    %rsi,0x18(%rsp)
mov    %edx,0x28(%rsp)
jae    1520 <minvf+0x400>
test   $0x1,%dl
jne    1670 <minvf+0x550>
mov    %esi,%eax
mov    (%rsp),%rdi
mov    %r14d,%edx
cmp    %r14d,0x44(%rsp)
jne    169f <minvf+0x57f>
jmp    16e3 <minvf+0x5c3>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movaps %xmm6,%xmm5
mov    %r14d,%edx
jmp    16e3 <minvf+0x5c3>
nopl   0x0(%rax,%rax,1)
lea    0x0(,%r14,4),%rax
mov    0x10(%rsp),%r10
sub    %rax,%r10
mov    $0x1,%ebx
xor    %r12d,%r12d
mov    0xb0(%rsp),%rdi
jmp    1584 <minvf+0x464>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  0x0(%r13,%rbx,4),%xmm5
subss  %xmm4,%xmm5
movss  %xmm5,0x0(%r13,%rbx,4)
add    $0x1,%rbx
add    %rcx,%rdi
cmp    0x8(%rsp),%rbx
je     13ee <minvf+0x2ce>
cmp    %ebx,%r9d
mov    %ebx,%eax
cmovb  %r9d,%eax
cmp    $0x2,%eax
mov    $0x1,%esi
cmovl  %esi,%eax
add    $0x1,%r12d
cmp    %r12d,%r14d
mov    %r12d,%edx
cmovb  %r14d,%edx
cmp    $0x2,%edx
cmovl  %esi,%edx
lea    -0x1(%rdx),%esi
cmp    $0x3,%esi
jae    15d0 <minvf+0x4b0>
mov    %rbx,%rsi
imul   0x8(%rsp),%rsi
lea    (%r10,%rsi,4),%rsi
xorps  %xmm4,%xmm4
mov    %r13,%rbp
test   $0x3,%dl
jne    1644 <minvf+0x524>
jmp    1560 <minvf+0x440>
xchg   %ax,%ax
mov    %eax,%esi
and    $0x7ffffffc,%esi
xorps  %xmm4,%xmm4
xor    %ebp,%ebp
xor    %r15d,%r15d
movss  (%rdi,%rbp,4),%xmm5
mulss  0x0(%r13,%rbp,4),%xmm5
movss  0x4(%rdi,%rbp,4),%xmm6
addss  %xmm4,%xmm5
mulss  0x4(%r13,%rbp,4),%xmm6
addss  %xmm5,%xmm6
movss  0x8(%rdi,%rbp,4),%xmm5
mulss  0x8(%r13,%rbp,4),%xmm5
addss  %xmm6,%xmm5
movss  0xc(%rdi,%rbp,4),%xmm4
mulss  0xc(%r13,%rbp,4),%xmm4
addss  %xmm5,%xmm4
add    $0xfffffffffffffff0,%r15
add    $0x4,%rbp
cmp    %ebp,%esi
jne    15e0 <minvf+0x4c0>
mov    %r13,%rbp
sub    %r15,%rbp
mov    %rdi,%rsi
sub    %r15,%rsi
test   $0x3,%dl
je     1560 <minvf+0x440>
and    $0x3,%eax
xor    %edx,%edx
nopl   0x0(%rax)
movss  (%rsi,%rdx,4),%xmm5
mulss  0x0(%rbp,%rdx,4),%xmm5
addss  %xmm5,%xmm4
add    $0x1,%rdx
cmp    %edx,%eax
jne    1650 <minvf+0x530>
jmp    1560 <minvf+0x440>
nopl   0x0(%rax)
mov    0x8(%rsp),%rax
mov    (%rsp),%rdx
lea    (%rdx,%rax,4),%rdi
movss  (%rdx,%rax,4),%xmm5
andps  %xmm1,%xmm5
ucomiss %xmm6,%xmm5
maxss  %xmm6,%xmm5
mov    %r14d,%edx
cmova  %esi,%edx
lea    0x1(%rsi),%eax
movaps %xmm5,%xmm6
cmp    %r14d,0x44(%rsp)
je     16e3 <minvf+0x5c3>
movaps %xmm6,%xmm5
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rdi,%rcx,1),%xmm6
andps  %xmm1,%xmm6
ucomiss %xmm5,%xmm6
maxss  %xmm5,%xmm6
cmova  %eax,%edx
movss  (%rdi,%r8,1),%xmm5
add    %r8,%rdi
andps  %xmm1,%xmm5
ucomiss %xmm6,%xmm5
lea    0x1(%rax),%esi
cmova  %esi,%edx
maxss  %xmm6,%xmm5
add    $0x2,%eax
cmp    %r15d,%eax
jne    16b0 <minvf+0x590>
maxss  %xmm5,%xmm0
movaps %xmm0,%xmm6
mulss  %xmm2,%xmm6
ucomiss %xmm5,%xmm6
ja     1a3c <minvf+0x91c>
mov    %edx,(%r12)
mov    %edx,%eax
cmp    %rax,%r14
je     1933 <minvf+0x813>
mov    %r14,%rsi
imul   0x8(%rsp),%rsi
mov    0x20(%rsp),%rbx
lea    (%rbx,%rsi,4),%r10
imul   %r15d,%edx
xor    %edi,%edi
movslq %edx,%rax
lea    (%rbx,%rax,4),%r12
cmpl   $0x7,0x30(%rsp)
jb     1840 <minvf+0x720>
mov    0x78(%rsp),%rdx
lea    (%rdx,%rax,4),%rdx
cmp    %rdx,%r10
jae    1758 <minvf+0x638>
add    0x80(%rsp),%rsi
mov    0x20(%rsp),%rdx
lea    (%rdx,%rsi,4),%rdx
cmp    %rdx,%r12
jb     1840 <minvf+0x720>
cmpq   $0x0,0x70(%rsp)
je     1a27 <minvf+0x907>
mov    0xc0(%rsp),%rdx
lea    (%rdx,%rax,4),%rdx
mov    0xa0(%rsp),%rsi
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movups -0x30(%r11,%rax,4),%xmm4
movups -0x20(%r11,%rax,4),%xmm5
movups -0x30(%rdx,%rax,4),%xmm6
movups -0x20(%rdx,%rax,4),%xmm7
movups %xmm6,-0x30(%r11,%rax,4)
movups %xmm7,-0x20(%r11,%rax,4)
movups %xmm4,-0x30(%rdx,%rax,4)
movups %xmm5,-0x20(%rdx,%rax,4)
movups -0x10(%r11,%rax,4),%xmm4
movups (%r11,%rax,4),%xmm5
movups -0x10(%rdx,%rax,4),%xmm6
movups (%rdx,%rax,4),%xmm7
movups %xmm6,-0x10(%r11,%rax,4)
movups %xmm7,(%r11,%rax,4)
movups %xmm4,-0x10(%rdx,%rax,4)
movups %xmm5,(%rdx,%rax,4)
add    $0x10,%rax
add    $0xfffffffffffffffe,%rsi
jne    1780 <minvf+0x660>
testb  $0x1,0xa8(%rsp)
01
je     1814 <minvf+0x6f4>
movups (%r10,%rax,4),%xmm4
movups 0x10(%r10,%rax,4),%xmm5
movups (%r12,%rax,4),%xmm6
movups 0x10(%r12,%rax,4),%xmm7
movups %xmm6,(%r10,%rax,4)
movups %xmm7,0x10(%r10,%rax,4)
movups %xmm4,(%r12,%rax,4)
movups %xmm5,0x10(%r12,%rax,4)
mov    0x60(%rsp),%rax
cmp    %rax,0x80(%rsp)
je     1914 <minvf+0x7f4>
mov    0x60(%rsp),%rax
lea    (%r12,%rax,4),%r12
lea    (%r10,%rax,4),%r10
mov    %eax,%edi
cs nopw 0x0(%rax,%rax,1)
mov    %r15d,%edx
sub    %edi,%edx
mov    %edi,%eax
not    %eax
add    %r15d,%eax
and    $0x3,%edx
je     1887 <minvf+0x767>
neg    %edx
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r10),%xmm4
movss  (%r12),%xmm5
movss  %xmm5,(%r10)
add    $0x4,%r10
movss  %xmm4,(%r12)
add    $0x4,%r12
add    $0xffffffff,%esi
cmp    %esi,%edx
jne    1860 <minvf+0x740>
sub    %esi,%edi
cmp    $0x3,%eax
jb     1914 <minvf+0x7f4>
mov    %r15d,%eax
sub    %edi,%eax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movss  (%r10,%rdx,4),%xmm4
movss  (%r12,%rdx,4),%xmm5
movss  %xmm5,(%r10,%rdx,4)
movss  %xmm4,(%r12,%rdx,4)
movss  0x4(%r10,%rdx,4),%xmm4
movss  0x4(%r12,%rdx,4),%xmm5
movss  %xmm5,0x4(%r10,%rdx,4)
movss  %xmm4,0x4(%r12,%rdx,4)
movss  0x8(%r10,%rdx,4),%xmm4
movss  0x8(%r12,%rdx,4),%xmm5
movss  %xmm5,0x8(%r10,%rdx,4)
movss  %xmm4,0x8(%r12,%rdx,4)
movss  0xc(%r10,%rdx,4),%xmm4
movss  0xc(%r12,%rdx,4),%xmm5
movss  %xmm5,0xc(%r10,%rdx,4)
movss  %xmm4,0xc(%r12,%rdx,4)
add    $0x4,%rdx
cmp    %edx,%eax
jne    18a0 <minvf+0x780>
mov    (%rsp),%rax
movss  (%rax),%xmm4
mov    0xb8(%rsp),%r12
mov    0x38(%rsp),%rbx
mov    0x68(%rsp),%rbp
mov    0x58(%rsp),%r10
movaps %xmm3,%xmm5
divss  %xmm4,%xmm5
movzbl %r10b,%r10d
and    $0x3,%r10d
mov    0x18(%rsp),%rax
cmp    0x8(%rsp),%rax
mov    0x98(%rsp),%rsi
jae    12e0 <minvf+0x1c0>
mov    0x44(%rsp),%edx
sub    %r14d,%edx
testb  $0x3,0x28(%rsp)
je     19b9 <minvf+0x899>
mov    $0xffffffff,%esi
mov    (%rsp),%rax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rcx,1),%xmm4
mulss  %xmm5,%xmm4
movss  %xmm4,(%rax,%rcx,1)
add    %rcx,%rax
mov    %esi,%edi
add    $0xffffffff,%esi
add    %r10d,%edi
add    $0xffffffff,%edi
cmp    $0xffffffff,%edi
jne    1980 <minvf+0x860>
mov    %r9d,%edi
sub    %esi,%edi
mov    0x98(%rsp),%rsi
cmp    $0x3,%edx
jb     12e0 <minvf+0x1c0>
jmp    19cd <minvf+0x8ad>
mov    0x18(%rsp),%rax
mov    %eax,%edi
mov    (%rsp),%rax
cmp    $0x3,%edx
jb     12e0 <minvf+0x1c0>
mov    %r15d,%edx
sub    %edi,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rax,%rcx,1),%xmm4
mulss  %xmm5,%xmm4
movss  %xmm4,(%rax,%rcx,1)
movss  (%rax,%r8,1),%xmm4
mulss  %xmm5,%xmm4
movss  %xmm4,(%rax,%r8,1)
movss  (%rax,%rsi,1),%xmm4
mulss  %xmm5,%xmm4
movss  %xmm4,(%rax,%rsi,1)
movss  (%rax,%rbx,1),%xmm4
mulss  %xmm5,%xmm4
movss  %xmm4,(%rax,%rbx,1)
add    %rbx,%rax
add    $0xfffffffc,%edx
jne    19e0 <minvf+0x8c0>
jmp    12e0 <minvf+0x1c0>
xor    %eax,%eax
testb  $0x1,0xa8(%rsp)
01
jne    17e8 <minvf+0x6c8>
jmp    1814 <minvf+0x6f4>
mov    $0xffffffff,%eax
jmp    2765 <minvf+0x1645>
xor    %eax,%eax
cmp    $0x2,%r15d
jl     2765 <minvf+0x1645>
lea    0x1(%r15),%r8d
mov    0x20(%rsp),%rax
lea    0x4(%rax),%r10
mov    $0x1,%ebx
xor    %r11d,%r11d
mov    %rax,%r9
jmp    1a84 <minvf+0x964>
nopl   0x0(%rax)
add    $0x1,%ebx
add    $0x1,%r11d
add    $0x4,%r10
cmp    %r15d,%ebx
je     1b29 <minvf+0xa09>
lea    (%rax,%r8,4),%rax
add    $0x4,%r9
mov    %r9,%rdx
cmp    $0x3,%r11d
jb     1af6 <minvf+0x9d6>
mov    %ebx,%edi
and    $0xfffffffc,%edi
mov    %r10,%rsi
nopl   (%rax)
movss  (%rax),%xmm0
mov    %rsi,%rdx
mulss  (%rsi),%xmm0
movss  %xmm0,(%rsi)
movss  (%rax),%xmm0
mulss  (%rsi,%rcx,1),%xmm0
movss  %xmm0,(%rsi,%rcx,1)
add    %rcx,%rsi
movss  (%rax),%xmm0
mulss  (%rcx,%rsi,1),%xmm0
lea    (%rsi,%rcx,1),%rbp
movss  %xmm0,(%rcx,%rsi,1)
movss  (%rax),%xmm0
mulss  (%rcx,%rbp,1),%xmm0
lea    (%rcx,%rbp,1),%rsi
movss  %xmm0,(%rcx,%rbp,1)
add    %rcx,%rsi
add    $0xfffffffc,%edi
jne    1aa0 <minvf+0x980>
add    0x38(%rsp),%rdx
mov    0x48(%rsp),%r15
test   $0x3,%bl
je     1a70 <minvf+0x950>
mov    %ebx,%edi
and    $0x3,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rax),%xmm0
mulss  (%rdx),%xmm0
movss  %xmm0,(%rdx)
add    %rcx,%rdx
add    $0xffffffff,%edi
jne    1b10 <minvf+0x9f0>
jmp    1a70 <minvf+0x950>
xor    %eax,%eax
cmp    $0x2,%r15d
jl     2765 <minvf+0x1645>
mov    0x20(%rsp),%rax
lea    0x4(%rax),%r8
mov    0x8(%rsp),%rdx
lea    0x8(,%rdx,8),%rsi
mov    %rsi,0x18(%rsp)
lea    0x4(%rax,%rdx,4),%rdx
mov    %rdx,0x38(%rsp)
mov    $0x1,%r9d
mov    $0x2,%edx
mov    %rdx,(%rsp)
xor    %ebx,%ebx
mov    %rax,%r10
jmp    1b8c <minvf+0xa6c>
add    $0x1,%r9
add    $0x1,%rbx
add    $0x4,%r8
addq   $0x1,(%rsp)
cmp    0x8(%rsp),%r9
je     1e8a <minvf+0xd6a>
mov    %r9d,%r12d
and    $0x7,%r12d
mov    %r9,%rax
and    $0xfffffffffffffff8,%rax
add    $0x4,%r10
mov    %r13,%rdx
mov    %r10,%rbp
mov    %rax,%rdi
mov    %r8,%rsi
cmp    $0x7,%rbx
jb     1c29 <minvf+0xb09>
mov    %rsi,%rbp
movss  (%rsi),%xmm0
movss  %xmm0,(%rdx)
add    %rcx,%rsi
movss  0x0(%rbp,%rcx,1),%xmm0
movss  %xmm0,0x4(%rdx)
movss  (%rcx,%rsi,1),%xmm0
add    %rcx,%rsi
movss  %xmm0,0x8(%rdx)
movss  (%rcx,%rsi,1),%xmm0
add    %rcx,%rsi
movss  %xmm0,0xc(%rdx)
movss  (%rcx,%rsi,1),%xmm0
add    %rcx,%rsi
movss  %xmm0,0x10(%rdx)
movss  (%rcx,%rsi,1),%xmm0
add    %rcx,%rsi
movss  %xmm0,0x14(%rdx)
movss  (%rcx,%rsi,1),%xmm0
add    %rcx,%rsi
movss  %xmm0,0x18(%rdx)
movss  (%rcx,%rsi,1),%xmm0
add    %rcx,%rsi
movss  %xmm0,0x1c(%rdx)
add    $0x20,%rdx
add    %rcx,%rsi
add    $0xfffffffffffffff8,%rdi
jne    1bb0 <minvf+0xa90>
add    0x50(%rsp),%rbp
test   $0x7,%r9b
je     1c56 <minvf+0xb36>
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
add    $0x1,%rsi
add    %rcx,%rbp
cmp    %rsi,%r12
jne    1c40 <minvf+0xb20>
test   %rbx,%rbx
mov    %r8,0x10(%rsp)
mov    %rbx,0x58(%rsp)
mov    %r10,0x28(%rsp)
je     1d40 <minvf+0xc20>
mov    %r9,%rbp
movabs $0x7ffffffffffffffe,%rdx
ff ff 7f
and    %rdx,%rbp
mov    $0x2,%edi
mov    0x38(%rsp),%r8
mov    0x20(%rsp),%r10
mov    %r13,%rsi
xor    %r14d,%r14d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %edi,%edx
mov    (%rsp),%r15
sub    %rdx,%r15
mov    %r14d,%ebx
mov    %r9,%r11
mov    %r9,%rdx
sub    %rbx,%rdx
xorps  %xmm0,%xmm0
xor    %r9d,%r9d
nopl   0x0(%rax,%rax,1)
movss  (%r10,%r9,4),%xmm1
mulss  (%rsi,%r9,4),%xmm1
subss  %xmm1,%xmm0
add    $0x1,%r9
cmp    %r9,%rdx
jne    1cc0 <minvf+0xba0>
movss  %xmm0,0x0(%r13,%r14,4)
mov    %r14,%rdx
or     $0x1,%rdx
xorps  %xmm0,%xmm0
xor    %ebx,%ebx
nopl   0x0(%rax)
movss  (%r8,%rbx,4),%xmm1
mulss  0x4(%rsi,%rbx,4),%xmm1
subss  %xmm1,%xmm0
add    $0x1,%rbx
cmp    %rbx,%r15
jne    1cf0 <minvf+0xbd0>
movss  %xmm0,0x0(%r13,%rdx,4)
add    $0x2,%r14
add    $0x8,%rsi
mov    0x18(%rsp),%rdx
add    %rdx,%r10
add    $0x2,%edi
add    %rdx,%r8
cmp    %rbp,%r14
mov    %r11,%r9
jne    1ca0 <minvf+0xb80>
jmp    1d43 <minvf+0xc23>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
xor    %r14d,%r14d
test   $0x1,%r9b
mov    0x10(%rsp),%r8
mov    0x58(%rsp),%rbx
mov    0x28(%rsp),%r10
je     1dbb <minvf+0xc9b>
lea    0x0(,%r9,4),%rdx
mov    %r10,%rdi
sub    %rdx,%rdi
lea    0x0(,%r14,4),%rsi
add    %r13,%rsi
mov    %r14,%rdx
imul   0x8(%rsp),%rdx
lea    (%rdi,%rdx,4),%rdx
lea    (%rdx,%r14,4),%rdi
add    $0x1,%r14d
mov    (%rsp),%rdx
sub    %r14,%rdx
xorps  %xmm0,%xmm0
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rdi,%rbp,4),%xmm1
mulss  (%rsi,%rbp,4),%xmm1
subss  %xmm1,%xmm0
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    1da0 <minvf+0xc80>
movss  %xmm0,(%rsi)
mov    %r13,%rdx
mov    %r10,%rsi
cmp    $0x7,%rbx
mov    0x48(%rsp),%r15
jb     1e58 <minvf+0xd38>
mov    %r8,%rdi
mov    %r13,%rdx
cs nopw 0x0(%rax,%rax,1)
mov    %rdi,%rsi
movss  (%rdx),%xmm0
movss  %xmm0,(%rdi)
movss  0x4(%rdx),%xmm0
add    %rcx,%rdi
movss  %xmm0,(%rsi,%rcx,1)
movss  0x8(%rdx),%xmm0
movss  %xmm0,(%rcx,%rdi,1)
add    %rcx,%rdi
movss  0xc(%rdx),%xmm0
movss  %xmm0,(%rcx,%rdi,1)
add    %rcx,%rdi
movss  0x10(%rdx),%xmm0
movss  %xmm0,(%rcx,%rdi,1)
add    %rcx,%rdi
movss  0x14(%rdx),%xmm0
movss  %xmm0,(%rcx,%rdi,1)
add    %rcx,%rdi
movss  0x18(%rdx),%xmm0
movss  %xmm0,(%rcx,%rdi,1)
add    %rcx,%rdi
movss  0x1c(%rdx),%xmm0
add    $0x20,%rdx
movss  %xmm0,(%rcx,%rdi,1)
add    %rcx,%rdi
add    %rcx,%rdi
add    $0xfffffffffffffff8,%rax
jne    1de0 <minvf+0xcc0>
add    0x50(%rsp),%rsi
test   $0x7,%r9b
je     1b70 <minvf+0xa50>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rdx,%rax,4),%xmm0
movss  %xmm0,(%rsi)
add    $0x1,%rax
add    %rcx,%rsi
cmp    %rax,%r12
jne    1e70 <minvf+0xd50>
jmp    1b70 <minvf+0xa50>
mov    %r15d,%eax
imul   %eax,%eax
mov    0x20(%rsp),%rsi
lea    (%rsi,%rax,4),%rcx
mov    %rcx,0x60(%rsp)
lea    (%rsi,%rax,4),%rdi
add    $0xfffffffffffffffc,%rdi
mov    %r15d,%ecx
not    %ecx
movslq %ecx,%rbp
movslq %r15d,%rcx
mov    %rcx,%rdx
neg    %rdx
mov    %rdx,0x10(%rsp)
lea    (%rcx,%rbp,1),%rdx
add    %rax,%rdx
mov    %rbp,0xa8(%rsp)
lea    0x0(,%rbp,4),%rax
mov    %rax,0xa0(%rsp)
mov    %rcx,%r14
shl    $0x5,%r14
lea    0x0(,%rcx,4),%r12
mov    %r12,%rax
neg    %rax
mov    %rax,0x58(%rsp)
lea    (%rsi,%rdx,4),%r10
add    $0xfffffffffffffffc,%r10
mov    $0x1,%r9d
xor    %eax,%eax
mov    %rax,0x28(%rsp)
mov    $0x1,%bpl
movaps 0x10fc(%rip),%xmm0
mov    0x44(%rsp),%eax
mov    %eax,%edx
mov    %rdi,0x70(%rsp)
mov    %rcx,(%rsp)
mov    %r14,0x90(%rsp)
jmp    1f6c <minvf+0xe4c>
nopl   (%rax)
mov    0x38(%rsp),%rdx
add    $0xffffffff,%edx
add    $0x1,%r9d
mov    0x28(%rsp),%rax
add    $0x1,%eax
mov    %rax,0x28(%rsp)
add    0xa0(%rsp),%r10
add    $0x1,%bpl
addq   $0xfffffffffffffffc,0x60(%rsp)
cmp    %r15d,%r9d
mov    0x88(%rsp),%rdi
je     22ea <minvf+0x11ca>
movzbl %bpl,%ebp
and    $0x7,%ebp
mov    %r9d,%eax
and    $0xfffffff8,%eax
mov    %eax,0x78(%rsp)
mov    0xa8(%rsp),%rax
lea    (%rdi,%rax,4),%rdi
mov    %rdx,0x38(%rsp)
mov    %edx,%eax
not    %eax
add    %r15d,%eax
mov    %rdi,0x88(%rsp)
lea    (%rdi,%rcx,4),%r8
mov    %eax,0x80(%rsp)
test   %eax,%eax
jle    2074 <minvf+0xf54>
mov    %r13,%rbx
mov    %r8,%rdx
cmpl   $0x7,0x28(%rsp)
jb     204f <minvf+0xf2f>
mov    0x78(%rsp),%esi
xor    %edx,%edx
mov    %r13,%rbx
mov    %r8,%rax
nopl   (%rax)
movss  (%r10,%rdx,1),%xmm1
movss  %xmm1,(%rbx)
lea    (%rax,%rcx,4),%rdi
movss  (%rax,%rcx,4),%xmm1
movss  %xmm1,0x4(%rbx)
lea    (%rdi,%rcx,4),%rax
movss  (%rdi,%rcx,4),%xmm1
movss  %xmm1,0x8(%rbx)
lea    (%rax,%rcx,4),%rdi
movss  (%rax,%rcx,4),%xmm1
movss  %xmm1,0xc(%rbx)
lea    (%rdi,%rcx,4),%rax
movss  (%rdi,%rcx,4),%xmm1
movss  %xmm1,0x10(%rbx)
lea    (%rax,%rcx,4),%rdi
movss  (%rax,%rcx,4),%xmm1
movss  %xmm1,0x14(%rbx)
lea    (%rdi,%rcx,4),%rax
movss  (%rdi,%rcx,4),%xmm1
movss  %xmm1,0x18(%rbx)
lea    (%rax,%rcx,4),%rdi
movss  (%rax,%rcx,4),%xmm1
movss  %xmm1,0x1c(%rbx)
add    $0x20,%rbx
lea    (%rdi,%rcx,4),%rax
add    %r14,%rdx
add    $0xfffffff8,%esi
jne    1fd0 <minvf+0xeb0>
add    %r10,%rdx
test   $0x7,%r9b
je     2074 <minvf+0xf54>
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movss  (%rdx),%xmm1
movss  %xmm1,(%rbx,%rax,4)
add    $0x1,%rax
add    %r12,%rdx
cmp    %eax,%ebp
jne    2060 <minvf+0xf40>
mov    %rbp,0xb0(%rsp)
mov    %r9d,0x68(%rsp)
mov    %r10,0x50(%rsp)
addq   $0xfffffffffffffffc,0x70(%rsp)
mov    0x38(%rsp),%rcx
cmp    %ecx,0x30(%rsp)
jle    21e0 <minvf+0x10c0>
mov    0x68(%rsp),%eax
movslq %eax,%r9
lea    0x1(%rcx),%edx
mov    %edx,0x18(%rsp)
neg    %eax
mov    %eax,0x98(%rsp)
xor    %r14d,%r14d
mov    0x28(%rsp),%rax
mov    %eax,%edi
mov    0x60(%rsp),%r15
mov    0x30(%rsp),%rax
mov    %eax,%ebx
mov    0x70(%rsp),%rbp
jmp    20fd <minvf+0xfdd>
nop
movss  %xmm1,-0x4(%r13,%r9,4)
add    $0xffffffffffffffff,%r9
mov    0x10(%rsp),%rax
lea    0x0(%rbp,%rax,4),%rbp
add    $0xffffffff,%ebx
add    $0x1,%r14d
add    0x58(%rsp),%r15
add    $0x3,%dil
cmp    %ecx,%ebx
jle    21e0 <minvf+0x10c0>
movss  0x0(%rbp),%xmm1
xorps  %xmm0,%xmm1
cmp    %ebx,0x18(%rsp)
jge    20d0 <minvf+0xfb0>
mov    %r14d,%ecx
not    %ecx
mov    0x28(%rsp),%rax
add    %eax,%ecx
sub    %r14d,%eax
test   $0x3,%al
je     2162 <minvf+0x1042>
movzbl %dil,%eax
and    $0x3,%eax
shl    $0x2,%rax
xor    %esi,%esi
mov    0x48(%rsp),%rdx
movss  -0x4(%r15,%rsi,1),%xmm2
mulss  0x0(%r13,%rsi,1),%xmm2
subss  %xmm2,%xmm1
add    $0x1,%edx
add    $0x4,%rsi
cmp    %esi,%eax
jne    2130 <minvf+0x1010>
add    0x98(%rsp),%edx
lea    (%rsi,%r13,1),%r11
lea    (%r15,%rsi,1),%r10
add    $0xfffffffffffffff8,%r10
jmp    216c <minvf+0x104c>
mov    0x18(%rsp),%edx
mov    %r13,%r11
mov    %rbp,%r10
cmp    $0x3,%ecx
mov    0x38(%rsp),%rcx
jb     20d0 <minvf+0xfb0>
mov    %edx,%edx
xor    %esi,%esi
xchg   %ax,%ax
movss  0x4(%r10,%rsi,4),%xmm2
mulss  (%r11,%rsi,4),%xmm2
movss  0x8(%r10,%rsi,4),%xmm3
subss  %xmm2,%xmm1
mulss  0x4(%r11,%rsi,4),%xmm3
subss  %xmm3,%xmm1
movss  0xc(%r10,%rsi,4),%xmm2
mulss  0x8(%r11,%rsi,4),%xmm2
subss  %xmm2,%xmm1
movss  0x10(%r10,%rsi,4),%xmm2
mulss  0xc(%r11,%rsi,4),%xmm2
subss  %xmm2,%xmm1
add    $0x4,%rsi
lea    (%rsi,%rdx,1),%eax
cmp    %ebx,%eax
jl     2180 <minvf+0x1060>
jmp    20d0 <minvf+0xfb0>
nopw   0x0(%rax,%rax,1)
cmpl   $0x0,0x80(%rsp)
mov    0x48(%rsp),%r15
mov    (%rsp),%rcx
mov    0x90(%rsp),%r14
mov    0x50(%rsp),%r10
mov    0x68(%rsp),%r9d
mov    0xb0(%rsp),%rbp
jle    1f30 <minvf+0xe10>
cmpl   $0x7,0x28(%rsp)
mov    0x78(%rsp),%ebx
jae    2230 <minvf+0x1110>
mov    %r13,%rdx
test   $0x7,%r9b
jne    22cd <minvf+0x11ad>
jmp    1f30 <minvf+0xe10>
xchg   %ax,%ax
xor    %esi,%esi
mov    %r13,%rdx
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rdx),%xmm1
movss  %xmm1,(%r10,%rsi,1)
lea    (%r8,%rcx,4),%rax
movss  0x4(%rdx),%xmm1
movss  %xmm1,(%r8,%rcx,4)
lea    (%rax,%rcx,4),%rdi
movss  0x8(%rdx),%xmm1
movss  %xmm1,(%rax,%rcx,4)
lea    (%rdi,%rcx,4),%rax
movss  0xc(%rdx),%xmm1
movss  %xmm1,(%rdi,%rcx,4)
lea    (%rax,%rcx,4),%rdi
movss  0x10(%rdx),%xmm1
movss  %xmm1,(%rax,%rcx,4)
lea    (%rdi,%rcx,4),%rax
movss  0x14(%rdx),%xmm1
movss  %xmm1,(%rdi,%rcx,4)
lea    (%rax,%rcx,4),%rdi
movss  0x18(%rdx),%xmm1
movss  %xmm1,(%rax,%rcx,4)
lea    (%rdi,%rcx,4),%rax
movss  0x1c(%rdx),%xmm1
add    $0x20,%rdx
movss  %xmm1,(%rdi,%rcx,4)
lea    (%rax,%rcx,4),%r8
add    %r14,%rsi
add    $0xfffffff8,%ebx
jne    2240 <minvf+0x1120>
add    %r10,%rsi
mov    %rsi,%r8
test   $0x7,%r9b
je     1f30 <minvf+0xe10>
xor    %eax,%eax
nop
movss  (%rdx,%rax,4),%xmm1
movss  %xmm1,(%r8)
add    $0x1,%rax
add    %r12,%r8
cmp    %eax,%ebp
jne    22d0 <minvf+0x11b0>
jmp    1f30 <minvf+0xe10>
mov    0x30(%rsp),%eax
mov    %rax,0x10(%rsp)
mov    %r15d,%eax
and    $0xfffffff8,%eax
mov    %eax,0x18(%rsp)
mov    %r15,%rax
and    $0x7,%r15d
lea    0xc(%r13),%r10
xor    %r9d,%r9d
mov    0x20(%rsp),%r11
jmp    2338 <minvf+0x1218>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r9
add    $0x4,%r11
cmp    0x10(%rsp),%r9
mov    0x48(%rsp),%rax
je     25fb <minvf+0x14db>
mov    %r13,%rdx
mov    %r11,%rdi
mov    0x18(%rsp),%esi
mov    %r11,%rbx
cmpl   $0x7,0x30(%rsp)
jb     23cc <minvf+0x12ac>
mov    %rbx,%rdi
movss  (%rbx),%xmm0
movss  %xmm0,(%rdx)
add    %r12,%rbx
movss  (%rdi,%r12,1),%xmm0
movss  %xmm0,0x4(%rdx)
movss  (%r12,%rbx,1),%xmm0
add    %r12,%rbx
movss  %xmm0,0x8(%rdx)
movss  (%r12,%rbx,1),%xmm0
add    %r12,%rbx
movss  %xmm0,0xc(%rdx)
movss  (%r12,%rbx,1),%xmm0
add    %r12,%rbx
movss  %xmm0,0x10(%rdx)
movss  (%r12,%rbx,1),%xmm0
add    %r12,%rbx
movss  %xmm0,0x14(%rdx)
movss  (%r12,%rbx,1),%xmm0
add    %r12,%rbx
movss  %xmm0,0x18(%rdx)
movss  (%r12,%rbx,1),%xmm0
add    %r12,%rbx
movss  %xmm0,0x1c(%rdx)
add    $0x20,%rdx
add    %r12,%rbx
add    $0xfffffff8,%esi
jne    2350 <minvf+0x1230>
add    %r14,%rdi
test   $0x7,%al
je     23f5 <minvf+0x12d5>
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rdi),%xmm0
movss  %xmm0,(%rdx,%rax,4)
add    $0x1,%rax
add    %r12,%rdi
cmp    %eax,%r15d
jne    23e0 <minvf+0x12c0>
lea    0x1(%r9),%r14d
xor    %edi,%edi
mov    0x20(%rsp),%rdx
jmp    242e <minvf+0x130e>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  %xmm0,0x0(%r13,%rdi,4)
add    $0x1,%rdi
mov    (%rsp),%rax
lea    (%rdx,%rax,4),%rdx
cmp    0x8(%rsp),%rdi
je     2520 <minvf+0x1400>
cmp    %r9,%rdi
mov    0x48(%rsp),%rcx
jbe    2450 <minvf+0x1330>
lea    (%rdx,%rdi,4),%rbx
xorps  %xmm0,%xmm0
mov    %edi,%eax
cmp    %ecx,%eax
jge    2410 <minvf+0x12f0>
jmp    2466 <minvf+0x1346>
nopw   0x0(%rax,%rax,1)
movss  0x0(%r13,%rdi,4),%xmm0
lea    (%rdx,%r9,4),%rbx
add    $0x4,%rbx
mov    %r14d,%eax
cmp    %ecx,%eax
jge    2410 <minvf+0x12f0>
mov    %eax,%esi
mov    0x8(%rsp),%rcx
mov    %ecx,%r8d
sub    %eax,%r8d
mov    %rsi,%rbp
not    %rbp
add    %rcx,%rbp
and    $0x3,%r8
je     24ad <minvf+0x138d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  (%rbx),%xmm1
mulss  0x0(%r13,%rsi,4),%xmm1
add    $0x4,%rbx
add    $0x1,%rsi
addss  %xmm1,%xmm0
add    $0xffffffffffffffff,%r8
jne    2490 <minvf+0x1370>
cmp    $0x3,%rbp
jb     2410 <minvf+0x12f0>
mov    0x8(%rsp),%rbp
sub    %rsi,%rbp
lea    (%r10,%rsi,4),%rsi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rbx,%rax,4),%xmm1
movss  0x4(%rbx,%rax,4),%xmm2
mulss  -0xc(%rsi,%rax,4),%xmm1
mulss  -0x8(%rsi,%rax,4),%xmm2
addss  %xmm0,%xmm1
movss  0x8(%rbx,%rax,4),%xmm3
mulss  -0x4(%rsi,%rax,4),%xmm3
addss  %xmm1,%xmm2
movss  0xc(%rbx,%rax,4),%xmm0
mulss  (%rsi,%rax,4),%xmm0
addss  %xmm2,%xmm3
addss  %xmm3,%xmm0
add    $0x4,%rax
cmp    %rax,%rbp
jne    24d0 <minvf+0x13b0>
jmp    2410 <minvf+0x12f0>
nopl   0x0(%rax)
mov    %r13,%rdx
mov    %r11,%rbp
cmpl   $0x7,0x30(%rsp)
mov    0x90(%rsp),%r14
jb     25cd <minvf+0x14ad>
mov    0x18(%rsp),%esi
mov    %r11,%rdi
mov    %r13,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rdi,%rbp
movss  (%rdx),%xmm0
movss  %xmm0,(%rdi)
movss  0x4(%rdx),%xmm0
add    %r12,%rdi
movss  %xmm0,0x0(%rbp,%r12,1)
movss  0x8(%rdx),%xmm0
movss  %xmm0,(%r12,%rdi,1)
add    %r12,%rdi
movss  0xc(%rdx),%xmm0
movss  %xmm0,(%r12,%rdi,1)
add    %r12,%rdi
movss  0x10(%rdx),%xmm0
movss  %xmm0,(%r12,%rdi,1)
add    %r12,%rdi
movss  0x14(%rdx),%xmm0
movss  %xmm0,(%r12,%rdi,1)
add    %r12,%rdi
movss  0x18(%rdx),%xmm0
movss  %xmm0,(%r12,%rdi,1)
add    %r12,%rdi
movss  0x1c(%rdx),%xmm0
add    $0x20,%rdx
movss  %xmm0,(%r12,%rdi,1)
add    %r12,%rdi
add    %r12,%rdi
add    $0xfffffff8,%esi
jne    2550 <minvf+0x1430>
add    %r14,%rbp
testb  $0x7,0x48(%rsp)
je     2320 <minvf+0x1200>
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
movss  (%rdx,%rax,4),%xmm0
movss  %xmm0,0x0(%rbp)
add    $0x1,%rax
add    %r12,%rbp
cmp    %eax,%r15d
jne    25e0 <minvf+0x14c0>
jmp    2320 <minvf+0x1200>
mov    0x44(%rsp),%r9d
mov    %eax,%r8d
and    $0x3,%r8d
and    $0xfffffffc,%eax
shlq   $0x4,(%rsp)
mov    0x20(%rsp),%r14
lea    (%r14,%r9,4),%r10
mov    %rax,%r11
mov    0xb8(%rsp),%rcx
jmp    264e <minvf+0x152e>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %r15,%rcx
add    $0xfffffffffffffffc,%rcx
lea    -0x1(%r9),%rax
add    $0xfffffffffffffffc,%r10
test   %r9,%r9
mov    %rax,%r9
mov    %r11,%rax
jle    2763 <minvf+0x1643>
mov    %rax,%rdx
mov    %rcx,%r15
movslq -0x4(%rcx),%rax
lea    (%r14,%rax,4),%rbx
cmpl   $0x3,0x30(%rsp)
jae    2680 <minvf+0x1560>
lea    (%r14,%r9,4),%rbp
test   %r8d,%r8d
jne    272c <minvf+0x160c>
jmp    2630 <minvf+0x1510>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %edx,%esi
mov    %r10,%rax
cs nopw 0x0(%rax,%rax,1)
nop
mov    %rbx,%rdx
mov    %rax,%rbp
movss  (%rax),%xmm0
movss  (%rbx),%xmm1
movss  %xmm1,(%rax)
movss  %xmm0,(%rbx)
add    %r12,%rax
movss  0x0(%rbp,%r12,1),%xmm0
lea    (%rbx,%r12,1),%rbx
movss  (%rdx,%r12,1),%xmm1
movss  %xmm1,0x0(%rbp,%r12,1)
movss  %xmm0,(%rdx,%r12,1)
lea    (%rax,%r12,1),%rdi
movss  (%r12,%rax,1),%xmm0
lea    (%rbx,%r12,1),%rcx
movss  (%r12,%rbx,1),%xmm1
movss  %xmm1,(%r12,%rax,1)
movss  %xmm0,(%r12,%rbx,1)
lea    (%rdi,%r12,1),%rax
movss  (%r12,%rdi,1),%xmm0
lea    (%rcx,%r12,1),%rbx
movss  (%r12,%rcx,1),%xmm1
movss  %xmm1,(%r12,%rdi,1)
movss  %xmm0,(%r12,%rcx,1)
add    %r12,%rax
add    %r12,%rbx
add    $0xfffffffc,%esi
jne    2690 <minvf+0x1570>
mov    (%rsp),%rax
add    %rax,%rdx
add    %rax,%rbp
mov    %rdx,%rbx
test   %r8d,%r8d
je     2630 <minvf+0x1510>
mov    %r8d,%eax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rdx,1),%xmm0
movss  (%rbx,%rdx,1),%xmm1
movss  %xmm1,0x0(%rbp,%rdx,1)
movss  %xmm0,(%rbx,%rdx,1)
add    %r12,%rdx
add    $0xffffffff,%eax
jne    2740 <minvf+0x1620>
jmp    2630 <minvf+0x1510>
xor    %eax,%eax
add    $0xc8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@minvf.sle = internal global i32* null
@minvf.sq0 = internal global float* null
@minvf.rsize = internal global i32 0
define i32 @minvf(float* %0, i32 %1) {
%3 = alloca i32
%4 = alloca float*
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32*
%8 = alloca float
%9 = alloca float
%10 = alloca float
%11 = alloca float
%12 = alloca float*
%13 = alloca float*
%14 = alloca float*
%15 = alloca float*
%16 = alloca float*
%17 = alloca float*
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
store float* %0, float** %4
store i32 %1, i32* %5
store float 0.000000e+00, float* %10
store float 0x3CD203AFA0000000, float* %11
%22 = load i32, i32* @minvf.rsize
%23 = load i32, i32* %5
%24 = icmp slt i32 %22, %23
br i1 %24, label %25, label %51
25: ; preds = %2
%26 = load i32*, i32** @minvf.sle
%27 = icmp ne i32* %26, null
br i1 %27, label %28, label %31
28: ; preds = %25
%29 = load i32*, i32** @minvf.sle
%30 = call i32 (i32*, ...) bitcast (i32 (...)* @MemFree to i32 (i32*, ...)*)(i32* %29)
br label %31
31: ; preds = %28, %25
%32 = load float*, float** @minvf.sq0
%33 = icmp ne float* %32, null
br i1 %33, label %34, label %37
34: ; preds = %31
%35 = load float*, float** @minvf.sq0
%36 = call i32 (float*, ...) bitcast (i32 (...)* @MemFree to i32 (float*, ...)*)(float* %35)
br label %37
37: ; preds = %34, %31
%38 = load i32, i32* %5
store i32 %38, i32* @minvf.rsize
%39 = load i32, i32* @minvf.rsize
%40 = sext i32 %39 to i64
%41 = mul i64 %40, 4
%42 = call i32 (i64, ...) bitcast (i32 (...)* @MemAlloc to i32 (i64, ...)*)(i64 %41)
%43 = sext i32 %42 to i64
%44 = inttoptr i64 %43 to i32*
store i32* %44, i32** @minvf.sle
%45 = load i32, i32* @minvf.rsize
%46 = sext i32 %45 to i64
%47 = mul i64 %46, 4
%48 = call i32 (i64, ...) bitcast (i32 (...)* @MemAlloc to i32 (i64, ...)*)(i64 %47)
%49 = sext i32 %48 to i64
%50 = inttoptr i64 %49 to float*
store float* %50, float** @minvf.sq0
br label %51
51: ; preds = %37, %2
%52 = load i32*, i32** @minvf.sle
store i32* %52, i32** %7
%53 = load float*, float** @minvf.sq0
store float* %53, float** %17
store i32 0, i32* %19
%54 = load float*, float** %4
store float* %54, float** %13
store float* %54, float** %12
br label %55
55: ; preds = %267, %51
%56 = load i32, i32* %19
%57 = load i32, i32* %5
%58 = icmp slt i32 %56, %57
br i1 %58, label %59, label %277
59: ; preds = %55
%60 = load i32, i32* %19
%61 = icmp sgt i32 %60, 0
br i1 %61, label %62, label %154
62: ; preds = %59
store i32 0, i32* %18
%63 = load float*, float** %17
store float* %63, float** %16
%64 = load float*, float** %12
store float* %64, float** %15
br label %65
65: ; preds = %74, %62
%66 = load i32, i32* %18
%67 = load i32, i32* %5
%68 = icmp slt i32 %66, %67
br i1 %68, label %69, label %81
69: ; preds = %65
%70 = load float*, float** %15
%71 = load float, float* %70
%72 = load float*, float** %16
%73 = getelementptr inbounds float, float* %72, i32 1
store float* %73, float** %16
store float %71, float* %72
br label %74
74: ; preds = %69
%75 = load i32, i32* %18
%76 = add nsw i32 %75, 1
store i32 %76, i32* %18
%77 = load i32, i32* %5
%78 = load float*, float** %15
%79 = sext i32 %77 to i64
%80 = getelementptr inbounds float, float* %78, i64 %79
store float* %80, float** %15
br label %65
81: ; preds = %65
store i32 1, i32* %18
br label %82
82: ; preds = %131, %81
%83 = load i32, i32* %18
%84 = load i32, i32* %5
%85 = icmp slt i32 %83, %84
br i1 %85, label %86, label %134
86: ; preds = %82
%87 = load i32, i32* %18
%88 = load i32, i32* %19
%89 = icmp slt i32 %87, %88
br i1 %89, label %90, label %92
90: ; preds = %86
%91 = load i32, i32* %18
br label %94
92: ; preds = %86
%93 = load i32, i32* %19
br label %94
94: ; preds = %92, %90
%95 = phi i32 [ %91, %90 ], [ %93, %92 ]
store i32 %95, i32* %6
store i32 0, i32* %20
%96 = load float*, float** %12
%97 = load i32, i32* %18
%98 = load i32, i32* %5
%99 = mul nsw i32 %97, %98
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds float, float* %96, i64 %100
%102 = load i32, i32* %19
%103 = sext i32 %102 to i64
%104 = sub i64 0, %103
%105 = getelementptr inbounds float, float* %101, i64 %104
store float* %105, float** %15
%106 = load float*, float** %17
store float* %106, float** %16
store float 0.000000e+00, float* %9
br label %107
107: ; preds = %120, %94
%108 = load i32, i32* %20
%109 = load i32, i32* %6
%110 = icmp slt i32 %108, %109
br i1 %110, label %111, label %123
111: ; preds = %107
%112 = load float*, float** %15
%113 = getelementptr inbounds float, float* %112, i32 1
store float* %113, float** %15
%114 = load float, float* %112
%115 = load float*, float** %16
%116 = getelementptr inbounds float, float* %115, i32 1
store float* %116, float** %16
%117 = load float, float* %115
%118 = load float, float* %9
%119 = call float @llvm.fmuladd.f32(float %114, float %117, float %118)
store float %119, float* %9
br label %120
120: ; preds = %111
%121 = load i32, i32* %20
%122 = add nsw i32 %121, 1
store i32 %122, i32* %20
br label %107
123: ; preds = %107
%124 = load float, float* %9
%125 = load float*, float** %17
%126 = load i32, i32* %18
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds float, float* %125, i64 %127
%129 = load float, float* %128
%130 = fsub float %129, %124
store float %130, float* %128
br label %131
131: ; preds = %123
%132 = load i32, i32* %18
%133 = add nsw i32 %132, 1
store i32 %133, i32* %18
br label %82
134: ; preds = %82
store i32 0, i32* %18
%135 = load float*, float** %17
store float* %135, float** %16
%136 = load float*, float** %12
store float* %136, float** %15
br label %137
137: ; preds = %146, %134
%138 = load i32, i32* %18
%139 = load i32, i32* %5
%140 = icmp slt i32 %138, %139
br i1 %140, label %141, label %153
141: ; preds = %137
%142 = load float*, float** %16
%143 = getelementptr inbounds float, float* %142, i32 1
store float* %143, float** %16
%144 = load float, float* %142
%145 = load float*, float** %15
store float %144, float* %145
br label %146
146: ; preds = %141
%147 = load i32, i32* %18
%148 = add nsw i32 %147, 1
store i32 %148, i32* %18
%149 = load i32, i32* %5
%150 = load float*, float** %15
%151 = sext i32 %149 to i64
%152 = getelementptr inbounds float, float* %150, i64 %151
store float* %152, float** %15
br label %137
153: ; preds = %137
br label %154
154: ; preds = %153, %59
%155 = load float*, float** %13
%156 = load float, float* %155
%157 = fpext float %156 to double
%158 = call double @llvm.fabs.f64(double %157)
%159 = fptrunc double %158 to float
store float %159, float* %8
%160 = load i32, i32* %19
store i32 %160, i32* %6
%161 = load i32, i32* %19
%162 = add nsw i32 %161, 1
store i32 %162, i32* %20
%163 = load float*, float** %13
store float* %163, float** %14
br label %164
164: ; preds = %183, %154
%165 = load i32, i32* %20
%166 = load i32, i32* %5
%167 = icmp slt i32 %165, %166
br i1 %167, label %168, label %186
168: ; preds = %164
%169 = load i32, i32* %5
%170 = load float*, float** %14
%171 = sext i32 %169 to i64
%172 = getelementptr inbounds float, float* %170, i64 %171
store float* %172, float** %14
%173 = load float, float* %172
%174 = fpext float %173 to double
%175 = call double @llvm.fabs.f64(double %174)
%176 = fptrunc double %175 to float
store float %176, float* %9
%177 = load float, float* %8
%178 = fcmp ogt float %176, %177
br i1 %178, label %179, label %182
179: ; preds = %168
%180 = load float, float* %9
store float %180, float* %8
%181 = load i32, i32* %20
store i32 %181, i32* %6
br label %182
182: ; preds = %179, %168
br label %183
183: ; preds = %182
%184 = load i32, i32* %20
%185 = add nsw i32 %184, 1
store i32 %185, i32* %20
br label %164
186: ; preds = %164
%187 = load float, float* %10
%188 = load float, float* %8
%189 = fcmp ogt float %187, %188
br i1 %189, label %190, label %192
190: ; preds = %186
%191 = load float, float* %10
br label %194
192: ; preds = %186
%193 = load float, float* %8
br label %194
194: ; preds = %192, %190
%195 = phi float [ %191, %190 ], [ %193, %192 ]
store float %195, float* %10
%196 = load float, float* %8
%197 = load float, float* %11
%198 = load float, float* %10
%199 = fmul float %197, %198
%200 = fcmp olt float %196, %199
br i1 %200, label %201, label %202
201: ; preds = %194
store i32 -1, i32* %3
br label %694
202: ; preds = %194
%203 = load i32, i32* %6
%204 = load i32*, i32** %7
%205 = getelementptr inbounds i32, i32* %204, i32 1
store i32* %205, i32** %7
store i32 %203, i32* %204
%206 = load i32, i32* %6
%207 = load i32, i32* %19
%208 = icmp ne i32 %206, %207
br i1 %208, label %209, label %240
209: ; preds = %202
store i32 0, i32* %20
%210 = load float*, float** %4
%211 = load i32, i32* %5
%212 = load i32, i32* %19
%213 = mul nsw i32 %211, %212
%214 = sext i32 %213 to i64
%215 = getelementptr inbounds float, float* %210, i64 %214
store float* %215, float** %15
%216 = load float*, float** %4
%217 = load i32, i32* %5
%218 = load i32, i32* %6
%219 = mul nsw i32 %217, %218
%220 = sext i32 %219 to i64
%221 = getelementptr inbounds float, float* %216, i64 %220
store float* %221, float** %16
br label %222
222: ; preds = %236, %209
%223 = load i32, i32* %20
%224 = load i32, i32* %5
%225 = icmp slt i32 %223, %224
br i1 %225, label %226, label %239
226: ; preds = %222
%227 = load float*, float** %15
%228 = load float, float* %227
store float %228, float* %9
%229 = load float*, float** %16
%230 = load float, float* %229
%231 = load float*, float** %15
%232 = getelementptr inbounds float, float* %231, i32 1
store float* %232, float** %15
store float %230, float* %231
%233 = load float, float* %9
%234 = load float*, float** %16
%235 = getelementptr inbounds float, float* %234, i32 1
store float* %235, float** %16
store float %233, float* %234
br label %236
236: ; preds = %226
%237 = load i32, i32* %20
%238 = add nsw i32 %237, 1
store i32 %238, i32* %20
br label %222
239: ; preds = %222
br label %240
240: ; preds = %239, %202
%241 = load i32, i32* %19
%242 = add nsw i32 %241, 1
store i32 %242, i32* %20
%243 = load float*, float** %13
store float* %243, float** %14
%244 = load float*, float** %13
%245 = load float, float* %244
%246 = fpext float %245 to double
%247 = fdiv double 1.000000e+00, %246
%248 = fptrunc double %247 to float
store float %248, float* %9
br label %249
249: ; preds = %261, %240
%250 = load i32, i32* %20
%251 = load i32, i32* %5
%252 = icmp slt i32 %250, %251
br i1 %252, label %253, label %264
253: ; preds = %249
%254 = load float, float* %9
%255 = load i32, i32* %5
%256 = load float*, float** %14
%257 = sext i32 %255 to i64
%258 = getelementptr inbounds float, float* %256, i64 %257
store float* %258, float** %14
%259 = load float, float* %258
%260 = fmul float %259, %254
store float %260, float* %258
br label %261
261: ; preds = %253
%262 = load i32, i32* %20
%263 = add nsw i32 %262, 1
store i32 %263, i32* %20
br label %249
264: ; preds = %249
%265 = load float, float* %9
%266 = load float*, float** %13
store float %265, float* %266
br label %267
267: ; preds = %264
%268 = load i32, i32* %19
%269 = add nsw i32 %268, 1
store i32 %269, i32* %19
%270 = load float*, float** %12
%271 = getelementptr inbounds float, float* %270, i32 1
store float* %271, float** %12
%272 = load i32, i32* %5
%273 = add nsw i32 %272, 1
%274 = load float*, float** %13
%275 = sext i32 %273 to i64
%276 = getelementptr inbounds float, float* %274, i64 %275
store float* %276, float** %13
br label %55
277: ; preds = %55
store i32 1, i32* %19
%278 = load float*, float** %4
store float* %278, float** %14
store float* %278, float** %13
br label %279
279: ; preds = %309, %277
%280 = load i32, i32* %19
%281 = load i32, i32* %5
%282 = icmp slt i32 %280, %281
br i1 %282, label %283, label %312
283: ; preds = %279
store i32 0, i32* %20
%284 = load i32, i32* %5
%285 = add nsw i32 %284, 1
%286 = load float*, float** %13
%287 = sext i32 %285 to i64
%288 = getelementptr inbounds float, float* %286, i64 %287
store float* %288, float** %13
%289 = load float*, float** %14
%290 = getelementptr inbounds float, float* %289, i32 1
store float* %290, float** %14
store float* %290, float** %16
br label %291
291: ; preds = %301, %283
%292 = load i32, i32* %20
%293 = load i32, i32* %19
%294 = icmp slt i32 %292, %293
br i1 %294, label %295, label %308
295: ; preds = %291
%296 = load float*, float** %13
%297 = load float, float* %296
%298 = load float*, float** %16
%299 = load float, float* %298
%300 = fmul float %299, %297
store float %300, float* %298
br label %301
301: ; preds = %295
%302 = load i32, i32* %20
%303 = add nsw i32 %302, 1
store i32 %303, i32* %20
%304 = load i32, i32* %5
%305 = load float*, float** %16
%306 = sext i32 %304 to i64
%307 = getelementptr inbounds float, float* %305, i64 %306
store float* %307, float** %16
br label %291
308: ; preds = %291
br label %309
309: ; preds = %308
%310 = load i32, i32* %19
%311 = add nsw i32 %310, 1
store i32 %311, i32* %19
br label %279
312: ; preds = %279
store i32 1, i32* %19
%313 = load float*, float** %4
store float* %313, float** %12
br label %314
314: ; preds = %409, %312
%315 = load i32, i32* %19
%316 = load i32, i32* %5
%317 = icmp slt i32 %315, %316
br i1 %317, label %318, label %412
318: ; preds = %314
%319 = load float*, float** %12
%320 = getelementptr inbounds float, float* %319, i32 1
store float* %320, float** %12
store i32 0, i32* %18
%321 = load float*, float** %17
store float* %321, float** %16
%322 = load float*, float** %12
store float* %322, float** %15
br label %323
323: ; preds = %332, %318
%324 = load i32, i32* %18
%325 = load i32, i32* %19
%326 = icmp slt i32 %324, %325
br i1 %326, label %327, label %339
327: ; preds = %323
%328 = load float*, float** %15
%329 = load float, float* %328
%330 = load float*, float** %16
%331 = getelementptr inbounds float, float* %330, i32 1
store float* %331, float** %16
store float %329, float* %330
br label %332
332: ; preds = %327
%333 = load i32, i32* %18
%334 = add nsw i32 %333, 1
store i32 %334, i32* %18
%335 = load i32, i32* %5
%336 = load float*, float** %15
%337 = sext i32 %335 to i64
%338 = getelementptr inbounds float, float* %336, i64 %337
store float* %338, float** %15
br label %323
339: ; preds = %323
store i32 0, i32* %20
br label %340
340: ; preds = %386, %339
%341 = load i32, i32* %20
%342 = load i32, i32* %19
%343 = icmp slt i32 %341, %342
br i1 %343, label %344, label %389
344: ; preds = %340
store float 0.000000e+00, float* %9
%345 = load i32, i32* %20
store i32 %345, i32* %18
%346 = load float*, float** %12
%347 = load i32, i32* %20
%348 = load i32, i32* %5
%349 = mul nsw i32 %347, %348
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds float, float* %346, i64 %350
%352 = load i32, i32* %20
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds float, float* %351, i64 %353
%355 = load i32, i32* %19
%356 = sext i32 %355 to i64
%357 = sub i64 0, %356
%358 = getelementptr inbounds float, float* %354, i64 %357
store float* %358, float** %15
%359 = load float*, float** %17
%360 = load i32, i32* %20
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds float, float* %359, i64 %361
store float* %362, float** %16
br label %363
363: ; preds = %377, %344
%364 = load i32, i32* %18
%365 = load i32, i32* %19
%366 = icmp slt i32 %364, %365
br i1 %366, label %367, label %380
367: ; preds = %363
%368 = load float*, float** %15
%369 = getelementptr inbounds float, float* %368, i32 1
store float* %369, float** %15
%370 = load float, float* %368
%371 = load float*, float** %16
%372 = getelementptr inbounds float, float* %371, i32 1
store float* %372, float** %16
%373 = load float, float* %371
%374 = load float, float* %9
%375 = fneg float %370
%376 = call float @llvm.fmuladd.f32(float %375, float %373, float %374)
store float %376, float* %9
br label %377
377: ; preds = %367
%378 = load i32, i32* %18
%379 = add nsw i32 %378, 1
store i32 %379, i32* %18
br label %363
380: ; preds = %363
%381 = load float, float* %9
%382 = load float*, float** %17
%383 = load i32, i32* %20
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds float, float* %382, i64 %384
store float %381, float* %385
br label %386
386: ; preds = %380
%387 = load i32, i32* %20
%388 = add nsw i32 %387, 1
store i32 %388, i32* %20
br label %340
389: ; preds = %340
store i32 0, i32* %18
%390 = load float*, float** %17
store float* %390, float** %16
%391 = load float*, float** %12
store float* %391, float** %15
br label %392
392: ; preds = %401, %389
%393 = load i32, i32* %18
%394 = load i32, i32* %19
%395 = icmp slt i32 %393, %394
br i1 %395, label %396, label %408
396: ; preds = %392
%397 = load float*, float** %16
%398 = getelementptr inbounds float, float* %397, i32 1
store float* %398, float** %16
%399 = load float, float* %397
%400 = load float*, float** %15
store float %399, float* %400
br label %401
401: ; preds = %396
%402 = load i32, i32* %18
%403 = add nsw i32 %402, 1
store i32 %403, i32* %18
%404 = load i32, i32* %5
%405 = load float*, float** %15
%406 = sext i32 %404 to i64
%407 = getelementptr inbounds float, float* %405, i64 %406
store float* %407, float** %15
br label %392
408: ; preds = %392
br label %409
409: ; preds = %408
%410 = load i32, i32* %19
%411 = add nsw i32 %410, 1
store i32 %411, i32* %19
br label %314
412: ; preds = %314
%413 = load i32, i32* %5
%414 = sub nsw i32 %413, 2
store i32 %414, i32* %19
%415 = load float*, float** %4
%416 = load i32, i32* %5
%417 = load i32, i32* %5
%418 = mul nsw i32 %416, %417
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds float, float* %415, i64 %419
%421 = getelementptr inbounds float, float* %420, i64 -1
store float* %421, float** %12
store float* %421, float** %13
br label %422
422: ; preds = %534, %412
%423 = load i32, i32* %19
%424 = icmp sge i32 %423, 0
br i1 %424, label %425, label %537
425: ; preds = %422
%426 = load float*, float** %12
%427 = getelementptr inbounds float, float* %426, i32 -1
store float* %427, float** %12
%428 = load i32, i32* %5
%429 = add nsw i32 %428, 1
%430 = load float*, float** %13
%431 = sext i32 %429 to i64
%432 = sub i64 0, %431
%433 = getelementptr inbounds float, float* %430, i64 %432
store float* %433, float** %13
store i32 0, i32* %18
%434 = load i32, i32* %5
%435 = load i32, i32* %19
%436 = sub nsw i32 %434, %435
%437 = sub nsw i32 %436, 1
store i32 %437, i32* %21
%438 = load float*, float** %17
store float* %438, float** %16
%439 = load float*, float** %13
%440 = load i32, i32* %5
%441 = sext i32 %440 to i64
%442 = getelementptr inbounds float, float* %439, i64 %441
store float* %442, float** %15
br label %443
443: ; preds = %452, %425
%444 = load i32, i32* %18
%445 = load i32, i32* %21
%446 = icmp slt i32 %444, %445
br i1 %446, label %447, label %459
447: ; preds = %443
%448 = load float*, float** %15
%449 = load float, float* %448
%450 = load float*, float** %16
%451 = getelementptr inbounds float, float* %450, i32 1
store float* %451, float** %16
store float %449, float* %450
br label %452
452: ; preds = %447
%453 = load i32, i32* %18
%454 = add nsw i32 %453, 1
store i32 %454, i32* %18
%455 = load i32, i32* %5
%456 = load float*, float** %15
%457 = sext i32 %455 to i64
%458 = getelementptr inbounds float, float* %456, i64 %457
store float* %458, float** %15
br label %443
459: ; preds = %443
%460 = load i32, i32* %5
%461 = sub nsw i32 %460, 1
store i32 %461, i32* %20
%462 = load float*, float** %12
store float* %462, float** %14
br label %463
463: ; preds = %499, %459
%464 = load i32, i32* %20
%465 = load i32, i32* %19
%466 = icmp sgt i32 %464, %465
br i1 %466, label %467, label %507
467: ; preds = %463
%468 = load float*, float** %14
%469 = load float, float* %468
%470 = fneg float %469
store float %470, float* %9
%471 = load i32, i32* %19
%472 = add nsw i32 %471, 1
store i32 %472, i32* %18
%473 = load float*, float** %14
store float* %473, float** %15
%474 = load float*, float** %17
store float* %474, float** %16
br label %475
475: ; preds = %489, %467
%476 = load i32, i32* %18
%477 = load i32, i32* %20
%478 = icmp slt i32 %476, %477
br i1 %478, label %479, label %492
479: ; preds = %475
%480 = load float*, float** %15
%481 = getelementptr inbounds float, float* %480, i32 1
store float* %481, float** %15
%482 = load float, float* %481
%483 = load float*, float** %16
%484 = getelementptr inbounds float, float* %483, i32 1
store float* %484, float** %16
%485 = load float, float* %483
%486 = load float, float* %9
%487 = fneg float %482
%488 = call float @llvm.fmuladd.f32(float %487, float %485, float %486)
store float %488, float* %9
br label %489
489: ; preds = %479
%490 = load i32, i32* %18
%491 = add nsw i32 %490, 1
store i32 %491, i32* %18
br label %475
492: ; preds = %475
%493 = load float, float* %9
%494 = load float*, float** %17
%495 = load i32, i32* %21
%496 = add nsw i32 %495, -1
store i32 %496, i32* %21
%497 = sext i32 %496 to i64
%498 = getelementptr inbounds float, float* %494, i64 %497
store float %493, float* %498
br label %499
499: ; preds = %492
%500 = load i32, i32* %20
%501 = add nsw i32 %500, -1
store i32 %501, i32* %20
%502 = load i32, i32* %5
%503 = load float*, float** %14
%504 = sext i32 %502 to i64
%505 = sub i64 0, %504
%506 = getelementptr inbounds float, float* %503, i64 %505
store float* %506, float** %14
br label %463
507: ; preds = %463
store i32 0, i32* %18
%508 = load i32, i32* %5
%509 = load i32, i32* %19
%510 = sub nsw i32 %508, %509
%511 = sub nsw i32 %510, 1
store i32 %511, i32* %21
%512 = load float*, float** %17
store float* %512, float** %16
%513 = load float*, float** %13
%514 = load i32, i32* %5
%515 = sext i32 %514 to i64
%516 = getelementptr inbounds float, float* %513, i64 %515
store float* %516, float** %15
br label %517
517: ; preds = %526, %507
%518 = load i32, i32* %18
%519 = load i32, i32* %21
%520 = icmp slt i32 %518, %519
br i1 %520, label %521, label %533
521: ; preds = %517
%522 = load float*, float** %16
%523 = getelementptr inbounds float, float* %522, i32 1
store float* %523, float** %16
%524 = load float, float* %522
%525 = load float*, float** %15
store float %524, float* %525
br label %526
526: ; preds = %521
%527 = load i32, i32* %18
%528 = add nsw i32 %527, 1
store i32 %528, i32* %18
%529 = load i32, i32* %5
%530 = load float*, float** %15
%531 = sext i32 %529 to i64
%532 = getelementptr inbounds float, float* %530, i64 %531
store float* %532, float** %15
br label %517
533: ; preds = %517
br label %534
534: ; preds = %533
%535 = load i32, i32* %19
%536 = add nsw i32 %535, -1
store i32 %536, i32* %19
br label %422
537: ; preds = %422
store i32 0, i32* %20
%538 = load float*, float** %4
store float* %538, float** %12
br label %539
539: ; preds = %642, %537
%540 = load i32, i32* %20
%541 = load i32, i32* %5
%542 = sub nsw i32 %541, 1
%543 = icmp slt i32 %540, %542
br i1 %543, label %544, label %647
544: ; preds = %539
store i32 0, i32* %18
%545 = load float*, float** %17
store float* %545, float** %16
%546 = load float*, float** %12
store float* %546, float** %15
br label %547
547: ; preds = %556, %544
%548 = load i32, i32* %18
%549 = load i32, i32* %5
%550 = icmp slt i32 %548, %549
br i1 %550, label %551, label %563
551: ; preds = %547
%552 = load float*, float** %15
%553 = load float, float* %552
%554 = load float*, float** %16
%555 = getelementptr inbounds float, float* %554, i32 1
store float* %555, float** %16
store float %553, float* %554
br label %556
556: ; preds = %551
%557 = load i32, i32* %18
%558 = add nsw i32 %557, 1
store i32 %558, i32* %18
%559 = load i32, i32* %5
%560 = load float*, float** %15
%561 = sext i32 %559 to i64
%562 = getelementptr inbounds float, float* %560, i64 %561
store float* %562, float** %15
br label %547
563: ; preds = %547
store i32 0, i32* %19
%564 = load float*, float** %4
store float* %564, float** %14
br label %565
565: ; preds = %615, %563
%566 = load i32, i32* %19
%567 = load i32, i32* %5
%568 = icmp slt i32 %566, %567
br i1 %568, label %569, label %622
569: ; preds = %565
%570 = load i32, i32* %19
%571 = load i32, i32* %20
%572 = icmp sgt i32 %570, %571
br i1 %572, label %573, label %579
573: ; preds = %569
store float 0.000000e+00, float* %9
%574 = load float*, float** %14
%575 = load i32, i32* %19
%576 = sext i32 %575 to i64
%577 = getelementptr inbounds float, float* %574, i64 %576
store float* %577, float** %15
%578 = load i32, i32* %19
store i32 %578, i32* %18
br label %592
579: ; preds = %569
%580 = load float*, float** %17
%581 = load i32, i32* %19
%582 = sext i32 %581 to i64
%583 = getelementptr inbounds float, float* %580, i64 %582
%584 = load float, float* %583
store float %584, float* %9
%585 = load float*, float** %14
%586 = load i32, i32* %20
%587 = sext i32 %586 to i64
%588 = getelementptr inbounds float, float* %585, i64 %587
%589 = getelementptr inbounds float, float* %588, i64 1
store float* %589, float** %15
%590 = load i32, i32* %20
%591 = add nsw i32 %590, 1
store i32 %591, i32* %18
br label %592
592: ; preds = %579, %573
br label %593
593: ; preds = %597, %592
%594 = load i32, i32* %18
%595 = load i32, i32* %5
%596 = icmp slt i32 %594, %595
br i1 %596, label %597, label %609
597: ; preds = %593
%598 = load float*, float** %15
%599 = getelementptr inbounds float, float* %598, i32 1
store float* %599, float** %15
%600 = load float, float* %598
%601 = load float*, float** %17
%602 = load i32, i32* %18
%603 = add nsw i32 %602, 1
store i32 %603, i32* %18
%604 = sext i32 %602 to i64
%605 = getelementptr inbounds float, float* %601, i64 %604
%606 = load float, float* %605
%607 = load float, float* %9
%608 = call float @llvm.fmuladd.f32(float %600, float %606, float %607)
store float %608, float* %9
br label %593
609: ; preds = %593
%610 = load float, float* %9
%611 = load float*, float** %17
%612 = load i32, i32* %19
%613 = sext i32 %612 to i64
%614 = getelementptr inbounds float, float* %611, i64 %613
store float %610, float* %614
br label %615
615: ; preds = %609
%616 = load i32, i32* %19
%617 = add nsw i32 %616, 1
store i32 %617, i32* %19
%618 = load i32, i32* %5
%619 = load float*, float** %14
%620 = sext i32 %618 to i64
%621 = getelementptr inbounds float, float* %619, i64 %620
store float* %621, float** %14
br label %565
622: ; preds = %565
store i32 0, i32* %18
%623 = load float*, float** %17
store float* %623, float** %16
%624 = load float*, float** %12
store float* %624, float** %15
br label %625
625: ; preds = %634, %622
%626 = load i32, i32* %18
%627 = load i32, i32* %5
%628 = icmp slt i32 %626, %627
br i1 %628, label %629, label %641
629: ; preds = %625
%630 = load float*, float** %16
%631 = getelementptr inbounds float, float* %630, i32 1
store float* %631, float** %16
%632 = load float, float* %630
%633 = load float*, float** %15
store float %632, float* %633
br label %634
634: ; preds = %629
%635 = load i32, i32* %18
%636 = add nsw i32 %635, 1
store i32 %636, i32* %18
%637 = load i32, i32* %5
%638 = load float*, float** %15
%639 = sext i32 %637 to i64
%640 = getelementptr inbounds float, float* %638, i64 %639
store float* %640, float** %15
br label %625
641: ; preds = %625
br label %642
642: ; preds = %641
%643 = load i32, i32* %20
%644 = add nsw i32 %643, 1
store i32 %644, i32* %20
%645 = load float*, float** %12
%646 = getelementptr inbounds float, float* %645, i32 1
store float* %646, float** %12
br label %539
647: ; preds = %539
%648 = load i32, i32* %5
%649 = sub nsw i32 %648, 2
store i32 %649, i32* %19
%650 = load i32*, i32** %7
%651 = getelementptr inbounds i32, i32* %650, i32 -1
store i32* %651, i32** %7
br label %652
652: ; preds = %690, %647
%653 = load i32, i32* %19
%654 = icmp sge i32 %653, 0
br i1 %654, label %655, label %693
655: ; preds = %652
store i32 0, i32* %20
%656 = load float*, float** %4
%657 = load i32, i32* %19
%658 = sext i32 %657 to i64
%659 = getelementptr inbounds float, float* %656, i64 %658
store float* %659, float** %15
%660 = load float*, float** %4
%661 = load i32*, i32** %7
%662 = getelementptr inbounds i32, i32* %661, i32 -1
store i32* %662, i32** %7
%663 = load i32, i32* %662
%664 = sext i32 %663 to i64
%665 = getelementptr inbounds float, float* %660, i64 %664
store float* %665, float** %16
br label %666
666: ; preds = %678, %655
%667 = load i32, i32* %20
%668 = load i32, i32* %5
%669 = icmp slt i32 %667, %668
br i1 %669, label %670, label %689
670: ; preds = %666
%671 = load float*, float** %15
%672 = load float, float* %671
store float %672, float* %9
%673 = load float*, float** %16
%674 = load float, float* %673
%675 = load float*, float** %15
store float %674, float* %675
%676 = load float, float* %9
%677 = load float*, float** %16
store float %676, float* %677
br label %678
678: ; preds = %670
%679 = load i32, i32* %20
%680 = add nsw i32 %679, 1
store i32 %680, i32* %20
%681 = load i32, i32* %5
%682 = load float*, float** %15
%683 = sext i32 %681 to i64
%684 = getelementptr inbounds float, float* %682, i64 %683
store float* %684, float** %15
%685 = load i32, i32* %5
%686 = load float*, float** %16
%687 = sext i32 %685 to i64
%688 = getelementptr inbounds float, float* %686, i64 %687
store float* %688, float** %16
br label %666
689: ; preds = %666
br label %690
690: ; preds = %689
%691 = load i32, i32* %19
%692 = add nsw i32 %691, -1
store i32 %692, i32* %19
br label %652
693: ; preds = %652
store i32 0, i32* %3
br label %694
694: ; preds = %693, %201
%695 = load i32, i32* %3
ret i32 %695
}

LLVM IR (-O2):
@minvf.sle = internal unnamed_addr global i32* null
@minvf.sq0 = internal unnamed_addr global float* null
@minvf.rsize = internal unnamed_addr global i32 0
define i32 @minvf(float* nocapture %0, i32 %1) {
%3 = load i32, i32* @minvf.rsize
%4 = icmp slt i32 %3, %1
br i1 %4, label %7, label %5
5: ; preds = %2
%6 = load float*, float** @minvf.sq0
br label %29
7: ; preds = %2
%8 = load i32*, i32** @minvf.sle
%9 = icmp eq i32* %8, null
br i1 %9, label %12, label %10
10: ; preds = %7
%11 = tail call i32 (i32*, ...) bitcast (i32 (...)* @MemFree to i32 (i32*, ...)*)(i32* %8)
br label %12
12: ; preds = %10, %7
%13 = load float*, float** @minvf.sq0
%14 = icmp eq float* %13, null
br i1 %14, label %17, label %15
15: ; preds = %12
%16 = tail call i32 (float*, ...) bitcast (i32 (...)* @MemFree to i32 (float*, ...)*)(float* %13)
br label %17
17: ; preds = %15, %12
store i32 %1, i32* @minvf.rsize
%18 = sext i32 %1 to i64
%19 = shl nsw i64 %18, 2
%20 = tail call i32 (i64, ...) bitcast (i32 (...)* @MemAlloc to i32 (i64, ...)*)(i64 %19)
%21 = sext i32 %20 to i64
%22 = inttoptr i64 %21 to i32*
store i32* %22, i32** @minvf.sle
%23 = load i32, i32* @minvf.rsize
%24 = sext i32 %23 to i64
%25 = shl nsw i64 %24, 2
%26 = tail call i32 (i64, ...) bitcast (i32 (...)* @MemAlloc to i32 (i64, ...)*)(i64 %25)
%27 = sext i32 %26 to i64
%28 = inttoptr i64 %27 to float*
store float* %28, float** @minvf.sq0
br label %29
29: ; preds = %5, %17
%30 = phi float* [ %6, %5 ], [ %28, %17 ]
%31 = icmp sgt i32 %1, 0
br i1 %31, label %32, label %1146
32: ; preds = %29
%33 = load i32*, i32** @minvf.sle
%34 = zext i32 %1 to i64
%35 = icmp eq i32 %1, 1
%36 = add nuw nsw i32 %1, 1
%37 = zext i32 %36 to i64
%38 = zext i32 %1 to i64
%39 = add i32 %1, -1
%40 = zext i32 %39 to i64
%41 = add nuw nsw i64 %40, 1
%42 = getelementptr float, float* %0, i64 %41
%43 = zext i32 %39 to i64
%44 = add nuw nsw i64 %43, 1
%45 = add i32 %1, -2
%46 = and i64 %44, 8589934584
%47 = add nsw i64 %46, -8
%48 = lshr exact i64 %47, 3
%49 = add nuw nsw i64 %48, 1
%50 = and i32 %1, 7
%51 = icmp ult i32 %39, 7
%52 = and i32 %1, -8
%53 = icmp eq i32 %50, 0
%54 = and i32 %1, 7
%55 = icmp ult i32 %39, 7
%56 = and i32 %1, -8
%57 = icmp eq i32 %54, 0
%58 = icmp ult i32 %39, 7
%59 = and i64 %44, 8589934584
%60 = trunc i64 %59 to i32
%61 = and i64 %49, 1
%62 = icmp eq i64 %47, 0
%63 = and i64 %49, 4611686018427387902
%64 = icmp eq i64 %61, 0
%65 = icmp eq i64 %44, %59
br label %72
66: ; preds = %465
%67 = icmp sgt i32 %1, 1
br i1 %67, label %68, label %1146
68: ; preds = %66
%69 = add nuw nsw i32 %1, 1
%70 = zext i32 %69 to i64
%71 = zext i32 %1 to i64
br label %473
72: ; preds = %32, %465
%73 = phi i64 [ 0, %32 ], [ %250, %465 ]
%74 = phi float* [ %0, %32 ], [ %467, %465 ]
%75 = phi float* [ %0, %32 ], [ %466, %465 ]
%76 = phi float [ 0.000000e+00, %32 ], [ %297, %465 ]
%77 = phi i32* [ %33, %32 ], [ %301, %465 ]
%78 = trunc i64 %73 to i32
%79 = sub i32 %39, %78
%80 = trunc i64 %73 to i32
%81 = sub i32 %45, %80
%82 = trunc i64 %73 to i32
%83 = sub i32 %39, %82
%84 = trunc i64 %73 to i32
%85 = trunc i64 %73 to i32
%86 = mul i64 %73, %38
%87 = getelementptr float, float* %0, i64 %86
%88 = add i64 %41, %86
%89 = getelementptr float, float* %0, i64 %88
%90 = icmp eq i64 %73, 0
br i1 %90, label %247, label %91
91: ; preds = %72
br i1 %51, label %92, label %108
92: ; preds = %108, %91
%93 = phi float* [ %30, %91 ], [ %134, %108 ]
%94 = phi float* [ %75, %91 ], [ %135, %108 ]
br i1 %53, label %104, label %95
95: ; preds = %92, %95
%96 = phi float* [ %100, %95 ], [ %93, %92 ]
%97 = phi float* [ %101, %95 ], [ %94, %92 ]
%98 = phi i32 [ %102, %95 ], [ 0, %92 ]
%99 = load float, float* %97
%100 = getelementptr inbounds float, float* %96, i64 1
store float %99, float* %96
%101 = getelementptr inbounds float, float* %97, i64 %34
%102 = add i32 %98, 1
%103 = icmp eq i32 %102, %50
br i1 %103, label %104, label %95
104: ; preds = %95, %92
br i1 %35, label %204, label %105
105: ; preds = %104
%106 = sub nsw i64 0, %73
%107 = getelementptr inbounds float, float* %75, i64 %106
br label %138
108: ; preds = %91, %108
%109 = phi float* [ %134, %108 ], [ %30, %91 ]
%110 = phi float* [ %135, %108 ], [ %75, %91 ]
%111 = phi i32 [ %136, %108 ], [ 0, %91 ]
%112 = load float, float* %110
%113 = getelementptr inbounds float, float* %109, i64 1
store float %112, float* %109
%114 = getelementptr inbounds float, float* %110, i64 %34
%115 = load float, float* %114
%116 = getelementptr inbounds float, float* %109, i64 2
store float %115, float* %113
%117 = getelementptr inbounds float, float* %114, i64 %34
%118 = load float, float* %117
%119 = getelementptr inbounds float, float* %109, i64 3
store float %118, float* %116
%120 = getelementptr inbounds float, float* %117, i64 %34
%121 = load float, float* %120
%122 = getelementptr inbounds float, float* %109, i64 4
store float %121, float* %119
%123 = getelementptr inbounds float, float* %120, i64 %34
%124 = load float, float* %123
%125 = getelementptr inbounds float, float* %109, i64 5
store float %124, float* %122
%126 = getelementptr inbounds float, float* %123, i64 %34
%127 = load float, float* %126
%128 = getelementptr inbounds float, float* %109, i64 6
store float %127, float* %125
%129 = getelementptr inbounds float, float* %126, i64 %34
%130 = load float, float* %129
%131 = getelementptr inbounds float, float* %109, i64 7
store float %130, float* %128
%132 = getelementptr inbounds float, float* %129, i64 %34
%133 = load float, float* %132
%134 = getelementptr inbounds float, float* %109, i64 8
store float %133, float* %131
%135 = getelementptr inbounds float, float* %132, i64 %34
%136 = add i32 %111, 8
%137 = icmp eq i32 %136, %52
br i1 %137, label %92, label %108
138: ; preds = %105, %196
%139 = phi i32 [ 0, %105 ], [ %203, %196 ]
%140 = phi i64 [ 1, %105 ], [ %201, %196 ]
%141 = add i32 %139, 1
%142 = call i32 @llvm.umin.i32(i32 %85, i32 %141)
%143 = call i32 @llvm.smax.i32(i32 %142, i32 1)
%144 = add nsw i32 %143, -1
%145 = mul nsw i64 %140, %34
%146 = getelementptr inbounds float, float* %107, i64 %145
%147 = and i32 %143, 3
%148 = icmp ult i32 %144, 3
br i1 %148, label %178, label %149
149: ; preds = %138
%150 = and i32 %143, 2147483644
br label %151
151: ; preds = %151, %149
%152 = phi float* [ %30, %149 ], [ %173, %151 ]
%153 = phi float* [ %146, %149 ], [ %171, %151 ]
%154 = phi float [ 0.000000e+00, %149 ], [ %175, %151 ]
%155 = phi i32 [ 0, %149 ], [ %176, %151 ]
%156 = getelementptr inbounds float, float* %153, i64 1
%157 = load float, float* %153
%158 = getelementptr inbounds float, float* %152, i64 1
%159 = load float, float* %152
%160 = tail call float @llvm.fmuladd.f32(float %157, float %159, float %154)
%161 = getelementptr inbounds float, float* %153, i64 2
%162 = load float, float* %156
%163 = getelementptr inbounds float, float* %152, i64 2
%164 = load float, float* %158
%165 = tail call float @llvm.fmuladd.f32(float %162, float %164, float %160)
%166 = getelementptr inbounds float, float* %153, i64 3
%167 = load float, float* %161
%168 = getelementptr inbounds float, float* %152, i64 3
%169 = load float, float* %163
%170 = tail call float @llvm.fmuladd.f32(float %167, float %169, float %165)
%171 = getelementptr inbounds float, float* %153, i64 4
%172 = load float, float* %166
%173 = getelementptr inbounds float, float* %152, i64 4
%174 = load float, float* %168
%175 = tail call float @llvm.fmuladd.f32(float %172, float %174, float %170)
%176 = add i32 %155, 4
%177 = icmp eq i32 %176, %150
br i1 %177, label %178, label %151
178: ; preds = %151, %138
%179 = phi float [ undef, %138 ], [ %175, %151 ]
%180 = phi float* [ %30, %138 ], [ %173, %151 ]
%181 = phi float* [ %146, %138 ], [ %171, %151 ]
%182 = phi float [ 0.000000e+00, %138 ], [ %175, %151 ]
%183 = icmp eq i32 %147, 0
br i1 %183, label %196, label %184
184: ; preds = %178, %184
%185 = phi float* [ %191, %184 ], [ %180, %178 ]
%186 = phi float* [ %189, %184 ], [ %181, %178 ]
%187 = phi float [ %193, %184 ], [ %182, %178 ]
%188 = phi i32 [ %194, %184 ], [ 0, %178 ]
%189 = getelementptr inbounds float, float* %186, i64 1
%190 = load float, float* %186
%191 = getelementptr inbounds float, float* %185, i64 1
%192 = load float, float* %185
%193 = tail call float @llvm.fmuladd.f32(float %190, float %192, float %187)
%194 = add i32 %188, 1
%195 = icmp eq i32 %194, %147
br i1 %195, label %196, label %184
196: ; preds = %184, %178
%197 = phi float [ %179, %178 ], [ %193, %184 ]
%198 = getelementptr inbounds float, float* %30, i64 %140
%199 = load float, float* %198
%200 = fsub float %199, %197
store float %200, float* %198
%201 = add nuw nsw i64 %140, 1
%202 = icmp eq i64 %201, %38
%203 = add i32 %139, 1
br i1 %202, label %204, label %138
204: ; preds = %196, %104
br i1 %55, label %235, label %205
205: ; preds = %204, %205
%206 = phi float* [ %230, %205 ], [ %30, %204 ]
%207 = phi float* [ %232, %205 ], [ %75, %204 ]
%208 = phi i32 [ %233, %205 ], [ 0, %204 ]
%209 = getelementptr inbounds float, float* %206, i64 1
%210 = load float, float* %206
store float %210, float* %207
%211 = getelementptr inbounds float, float* %207, i64 %34
%212 = getelementptr inbounds float, float* %206, i64 2
%213 = load float, float* %209
store float %213, float* %211
%214 = getelementptr inbounds float, float* %211, i64 %34
%215 = getelementptr inbounds float, float* %206, i64 3
%216 = load float, float* %212
store float %216, float* %214
%217 = getelementptr inbounds float, float* %214, i64 %34
%218 = getelementptr inbounds float, float* %206, i64 4
%219 = load float, float* %215
store float %219, float* %217
%220 = getelementptr inbounds float, float* %217, i64 %34
%221 = getelementptr inbounds float, float* %206, i64 5
%222 = load float, float* %218
store float %222, float* %220
%223 = getelementptr inbounds float, float* %220, i64 %34
%224 = getelementptr inbounds float, float* %206, i64 6
%225 = load float, float* %221
store float %225, float* %223
%226 = getelementptr inbounds float, float* %223, i64 %34
%227 = getelementptr inbounds float, float* %206, i64 7
%228 = load float, float* %224
store float %228, float* %226
%229 = getelementptr inbounds float, float* %226, i64 %34
%230 = getelementptr inbounds float, float* %206, i64 8
%231 = load float, float* %227
store float %231, float* %229
%232 = getelementptr inbounds float, float* %229, i64 %34
%233 = add i32 %208, 8
%234 = icmp eq i32 %233, %56
br i1 %234, label %235, label %205
235: ; preds = %205, %204
%236 = phi float* [ %30, %204 ], [ %230, %205 ]
%237 = phi float* [ %75, %204 ], [ %232, %205 ]
br i1 %57, label %247, label %238
238: ; preds = %235, %238
%239 = phi float* [ %242, %238 ], [ %236, %235 ]
%240 = phi float* [ %244, %238 ], [ %237, %235 ]
%241 = phi i32 [ %245, %238 ], [ 0, %235 ]
%242 = getelementptr inbounds float, float* %239, i64 1
%243 = load float, float* %239
store float %243, float* %240
%244 = getelementptr inbounds float, float* %240, i64 %34
%245 = add i32 %241, 1
%246 = icmp eq i32 %245, %54
br i1 %246, label %247, label %238
247: ; preds = %235, %238, %72
%248 = load float, float* %74
%249 = tail call float @llvm.fabs.f32(float %248)
%250 = add nuw nsw i64 %73, 1
%251 = icmp ult i64 %250, %34
%252 = trunc i64 %73 to i32
br i1 %251, label %253, label %293
253: ; preds = %247
%254 = trunc i64 %250 to i32
%255 = and i32 %83, 1
%256 = icmp eq i32 %255, 0
br i1 %256, label %265, label %257
257: ; preds = %253
%258 = getelementptr inbounds float, float* %74, i64 %34
%259 = load float, float* %258
%260 = tail call float @llvm.fabs.f32(float %259)
%261 = fcmp ogt float %260, %249
%262 = select i1 %261, float %260, float %249
%263 = select i1 %261, i32 %254, i32 %252
%264 = add nuw nsw i32 %254, 1
br label %265
265: ; preds = %257, %253
%266 = phi float [ undef, %253 ], [ %262, %257 ]
%267 = phi i32 [ undef, %253 ], [ %263, %257 ]
%268 = phi i32 [ %254, %253 ], [ %264, %257 ]
%269 = phi float* [ %74, %253 ], [ %258, %257 ]
%270 = phi i32 [ %252, %253 ], [ %263, %257 ]
%271 = phi float [ %249, %253 ], [ %262, %257 ]
%272 = icmp eq i32 %45, %84
br i1 %272, label %293, label %273
273: ; preds = %265, %273
%274 = phi i32 [ %291, %273 ], [ %268, %265 ]
%275 = phi float* [ %285, %273 ], [ %269, %265 ]
%276 = phi i32 [ %290, %273 ], [ %270, %265 ]
%277 = phi float [ %289, %273 ], [ %271, %265 ]
%278 = getelementptr inbounds float, float* %275, i64 %34
%279 = load float, float* %278
%280 = tail call float @llvm.fabs.f32(float %279)
%281 = fcmp ogt float %280, %277
%282 = select i1 %281, float %280, float %277
%283 = select i1 %281, i32 %274, i32 %276
%284 = add nuw nsw i32 %274, 1
%285 = getelementptr inbounds float, float* %278, i64 %34
%286 = load float, float* %285
%287 = tail call float @llvm.fabs.f32(float %286)
%288 = fcmp ogt float %287, %282
%289 = select i1 %288, float %287, float %282
%290 = select i1 %288, i32 %284, i32 %283
%291 = add nuw nsw i32 %274, 2
%292 = icmp eq i32 %291, %1
br i1 %292, label %293, label %273
293: ; preds = %265, %273, %247
%294 = phi float [ %249, %247 ], [ %266, %265 ], [ %289, %273 ]
%295 = phi i32 [ %252, %247 ], [ %267, %265 ], [ %290, %273 ]
%296 = fcmp ogt float %76, %294
%297 = select i1 %296, float %76, float %294
%298 = fmul float %297, 0x3CD203AFA0000000
%299 = fcmp olt float %294, %298
br i1 %299, label %1146, label %300
300: ; preds = %293
%301 = getelementptr inbounds i32, i32* %77, i64 1
store i32 %295, i32* %77
%302 = zext i32 %295 to i64
%303 = icmp eq i64 %73, %302
br i1 %303, label %427, label %304
304: ; preds = %300
%305 = mul nsw i32 %295, %1
%306 = sext i32 %305 to i64
%307 = getelementptr float, float* %0, i64 %306
%308 = mul nsw i64 %73, %34
%309 = getelementptr inbounds float, float* %0, i64 %308
br i1 %58, label %377, label %310
310: ; preds = %304
%311 = getelementptr float, float* %42, i64 %306
%312 = icmp ult float* %87, %311
%313 = icmp ult float* %307, %89
%314 = and i1 %312, %313
br i1 %314, label %377, label %315
315: ; preds = %310
%316 = getelementptr float, float* %307, i64 %59
%317 = getelementptr float, float* %309, i64 %59
br i1 %62, label %357, label %318
318: ; preds = %315, %318
%319 = phi i64 [ %354, %318 ], [ 0, %315 ]
%320 = phi i64 [ %355, %318 ], [ 0, %315 ]
%321 = getelementptr float, float* %307, i64 %319
%322 = getelementptr float, float* %309, i64 %319
%323 = bitcast float* %322 to <4 x float>*
%324 = load <4 x float>, <4 x float>* %323
%325 = getelementptr float, float* %322, i64 4
%326 = bitcast float* %325 to <4 x float>*
%327 = load <4 x float>, <4 x float>* %326
%328 = bitcast float* %321 to <4 x float>*
%329 = load <4 x float>, <4 x float>* %328
%330 = getelementptr float, float* %321, i64 4
%331 = bitcast float* %330 to <4 x float>*
%332 = load <4 x float>, <4 x float>* %331
%333 = bitcast float* %322 to <4 x float>*
store <4 x float> %329, <4 x float>* %333
%334 = bitcast float* %325 to <4 x float>*
store <4 x float> %332, <4 x float>* %334
%335 = bitcast float* %321 to <4 x float>*
store <4 x float> %324, <4 x float>* %335
%336 = bitcast float* %330 to <4 x float>*
store <4 x float> %327, <4 x float>* %336
%337 = or i64 %319, 8
%338 = getelementptr float, float* %307, i64 %337
%339 = getelementptr float, float* %309, i64 %337
%340 = bitcast float* %339 to <4 x float>*
%341 = load <4 x float>, <4 x float>* %340
%342 = getelementptr float, float* %339, i64 4
%343 = bitcast float* %342 to <4 x float>*
%344 = load <4 x float>, <4 x float>* %343
%345 = bitcast float* %338 to <4 x float>*
%346 = load <4 x float>, <4 x float>* %345
%347 = getelementptr float, float* %338, i64 4
%348 = bitcast float* %347 to <4 x float>*
%349 = load <4 x float>, <4 x float>* %348
%350 = bitcast float* %339 to <4 x float>*
store <4 x float> %346, <4 x float>* %350
%351 = bitcast float* %342 to <4 x float>*
store <4 x float> %349, <4 x float>* %351
%352 = bitcast float* %338 to <4 x float>*
store <4 x float> %341, <4 x float>* %352
%353 = bitcast float* %347 to <4 x float>*
store <4 x float> %344, <4 x float>* %353
%354 = add nuw i64 %319, 16
%355 = add i64 %320, 2
%356 = icmp eq i64 %355, %63
br i1 %356, label %357, label %318
357: ; preds = %318, %315
%358 = phi i64 [ 0, %315 ], [ %354, %318 ]
br i1 %64, label %376, label %359
359: ; preds = %357
%360 = getelementptr float, float* %307, i64 %358
%361 = getelementptr float, float* %309, i64 %358
%362 = bitcast float* %361 to <4 x float>*
%363 = load <4 x float>, <4 x float>* %362
%364 = getelementptr float, float* %361, i64 4
%365 = bitcast float* %364 to <4 x float>*
%366 = load <4 x float>, <4 x float>* %365
%367 = bitcast float* %360 to <4 x float>*
%368 = load <4 x float>, <4 x float>* %367
%369 = getelementptr float, float* %360, i64 4
%370 = bitcast float* %369 to <4 x float>*
%371 = load <4 x float>, <4 x float>* %370
%372 = bitcast float* %361 to <4 x float>*
store <4 x float> %368, <4 x float>* %372
%373 = bitcast float* %364 to <4 x float>*
store <4 x float> %371, <4 x float>* %373
%374 = bitcast float* %360 to <4 x float>*
store <4 x float> %363, <4 x float>* %374
%375 = bitcast float* %369 to <4 x float>*
store <4 x float> %366, <4 x float>* %375
br label %376
376: ; preds = %357, %359
br i1 %65, label %425, label %377
377: ; preds = %310, %304, %376
%378 = phi i32 [ 0, %310 ], [ 0, %304 ], [ %60, %376 ]
%379 = phi float* [ %307, %310 ], [ %307, %304 ], [ %316, %376 ]
%380 = phi float* [ %309, %310 ], [ %309, %304 ], [ %317, %376 ]
%381 = sub i32 %1, %378
%382 = xor i32 %378, -1
%383 = add i32 %382, %1
%384 = and i32 %381, 3
%385 = icmp eq i32 %384, 0
br i1 %385, label %398, label %386
386: ; preds = %377, %386
%387 = phi i32 [ %395, %386 ], [ %378, %377 ]
%388 = phi float* [ %394, %386 ], [ %379, %377 ]
%389 = phi float* [ %393, %386 ], [ %380, %377 ]
%390 = phi i32 [ %396, %386 ], [ 0, %377 ]
%391 = load float, float* %389
%392 = load float, float* %388
%393 = getelementptr inbounds float, float* %389, i64 1
store float %392, float* %389
%394 = getelementptr inbounds float, float* %388, i64 1
store float %391, float* %388
%395 = add nuw nsw i32 %387, 1
%396 = add i32 %390, 1
%397 = icmp eq i32 %396, %384
br i1 %397, label %398, label %386
398: ; preds = %386, %377
%399 = phi i32 [ %378, %377 ], [ %395, %386 ]
%400 = phi float* [ %379, %377 ], [ %394, %386 ]
%401 = phi float* [ %380, %377 ], [ %393, %386 ]
%402 = icmp ult i32 %383, 3
br i1 %402, label %425, label %403
403: ; preds = %398, %403
%404 = phi i32 [ %423, %403 ], [ %399, %398 ]
%405 = phi float* [ %422, %403 ], [ %400, %398 ]
%406 = phi float* [ %421, %403 ], [ %401, %398 ]
%407 = load float, float* %406
%408 = load float, float* %405
%409 = getelementptr inbounds float, float* %406, i64 1
store float %408, float* %406
%410 = getelementptr inbounds float, float* %405, i64 1
store float %407, float* %405
%411 = load float, float* %409
%412 = load float, float* %410
%413 = getelementptr inbounds float, float* %406, i64 2
store float %412, float* %409
%414 = getelementptr inbounds float, float* %405, i64 2
store float %411, float* %410
%415 = load float, float* %413
%416 = load float, float* %414
%417 = getelementptr inbounds float, float* %406, i64 3
store float %416, float* %413
%418 = getelementptr inbounds float, float* %405, i64 3
store float %415, float* %414
%419 = load float, float* %417
%420 = load float, float* %418
%421 = getelementptr inbounds float, float* %406, i64 4
store float %420, float* %417
%422 = getelementptr inbounds float, float* %405, i64 4
store float %419, float* %418
%423 = add nuw nsw i32 %404, 4
%424 = icmp eq i32 %423, %1
br i1 %424, label %425, label %403
425: ; preds = %398, %403, %376
%426 = load float, float* %74
br label %427
427: ; preds = %425, %300
%428 = phi float [ %426, %425 ], [ %248, %300 ]
%429 = fdiv float 1.000000e+00, %428
br i1 %251, label %430, label %465
430: ; preds = %427
%431 = trunc i64 %250 to i32
%432 = and i32 %79, 3
%433 = icmp eq i32 %432, 0
br i1 %433, label %444, label %434
434: ; preds = %430, %434
%435 = phi i32 [ %441, %434 ], [ %431, %430 ]
%436 = phi float* [ %438, %434 ], [ %74, %430 ]
%437 = phi i32 [ %442, %434 ], [ 0, %430 ]
%438 = getelementptr inbounds float, float* %436, i64 %34
%439 = load float, float* %438
%440 = fmul float %429, %439
store float %440, float* %438
%441 = add nuw nsw i32 %435, 1
%442 = add i32 %437, 1
%443 = icmp eq i32 %442, %432
br i1 %443, label %444, label %434
444: ; preds = %434, %430
%445 = phi i32 [ %431, %430 ], [ %441, %434 ]
%446 = phi float* [ %74, %430 ], [ %438, %434 ]
%447 = icmp ult i32 %81, 3
br i1 %447, label %465, label %448
448: ; preds = %444, %448
%449 = phi i32 [ %463, %448 ], [ %445, %444 ]
%450 = phi float* [ %460, %448 ], [ %446, %444 ]
%451 = getelementptr inbounds float, float* %450, i64 %34
%452 = load float, float* %451
%453 = fmul float %429, %452
store float %453, float* %451
%454 = getelementptr inbounds float, float* %451, i64 %34
%455 = load float, float* %454
%456 = fmul float %429, %455
store float %456, float* %454
%457 = getelementptr inbounds float, float* %454, i64 %34
%458 = load float, float* %457
%459 = fmul float %429, %458
store float %459, float* %457
%460 = getelementptr inbounds float, float* %457, i64 %34
%461 = load float, float* %460
%462 = fmul float %429, %461
store float %462, float* %460
%463 = add nuw nsw i32 %449, 4
%464 = icmp eq i32 %463, %1
br i1 %464, label %465, label %448
465: ; preds = %444, %448, %427
store float %429, float* %74
%466 = getelementptr inbounds float, float* %75, i64 1
%467 = getelementptr inbounds float, float* %74, i64 %37
%468 = icmp eq i64 %250, %38
br i1 %468, label %66, label %72
469: ; preds = %517
br i1 %67, label %470, label %1146
470: ; preds = %469
%471 = zext i32 %1 to i64
%472 = zext i32 %1 to i64
br label %521
473: ; preds = %68, %517
%474 = phi i32 [ 0, %68 ], [ %520, %517 ]
%475 = phi i32 [ 1, %68 ], [ %518, %517 ]
%476 = phi float* [ %0, %68 ], [ %479, %517 ]
%477 = phi float* [ %0, %68 ], [ %478, %517 ]
%478 = getelementptr inbounds float, float* %477, i64 %70
%479 = getelementptr inbounds float, float* %476, i64 1
%480 = and i32 %475, 3
%481 = icmp ult i32 %474, 3
br i1 %481, label %505, label %482
482: ; preds = %473
%483 = and i32 %475, 2147483644
br label %484
484: ; preds = %484, %482
%485 = phi float* [ %479, %482 ], [ %502, %484 ]
%486 = phi i32 [ 0, %482 ], [ %503, %484 ]
%487 = load float, float* %478
%488 = load float, float* %485
%489 = fmul float %487, %488
store float %489, float* %485
%490 = getelementptr inbounds float, float* %485, i64 %71
%491 = load float, float* %478
%492 = load float, float* %490
%493 = fmul float %491, %492
store float %493, float* %490
%494 = getelementptr inbounds float, float* %490, i64 %71
%495 = load float, float* %478
%496 = load float, float* %494
%497 = fmul float %495, %496
store float %497, float* %494
%498 = getelementptr inbounds float, float* %494, i64 %71
%499 = load float, float* %478
%500 = load float, float* %498
%501 = fmul float %499, %500
store float %501, float* %498
%502 = getelementptr inbounds float, float* %498, i64 %71
%503 = add i32 %486, 4
%504 = icmp eq i32 %503, %483
br i1 %504, label %505, label %484
505: ; preds = %484, %473
%506 = phi float* [ %479, %473 ], [ %502, %484 ]
%507 = icmp eq i32 %480, 0
br i1 %507, label %517, label %508
508: ; preds = %505, %508
%509 = phi float* [ %514, %508 ], [ %506, %505 ]
%510 = phi i32 [ %515, %508 ], [ 0, %505 ]
%511 = load float, float* %478
%512 = load float, float* %509
%513 = fmul float %511, %512
store float %513, float* %509
%514 = getelementptr inbounds float, float* %509, i64 %71
%515 = add i32 %510, 1
%516 = icmp eq i32 %515, %480
br i1 %516, label %517, label %508
517: ; preds = %508, %505
%518 = add nuw nsw i32 %475, 1
%519 = icmp eq i32 %518, %1
%520 = add i32 %474, 1
br i1 %519, label %469, label %473
521: ; preds = %470, %699
%522 = phi i64 [ 0, %470 ], [ %702, %699 ]
%523 = phi i64 [ 1, %470 ], [ %700, %699 ]
%524 = phi float* [ %0, %470 ], [ %525, %699 ]
%525 = getelementptr inbounds float, float* %524, i64 1
%526 = and i64 %523, 7
%527 = icmp ult i64 %522, 7
br i1 %527, label %530, label %528
528: ; preds = %521
%529 = and i64 %523, 9223372036854775800
br label %550
530: ; preds = %550, %521
%531 = phi float* [ %30, %521 ], [ %576, %550 ]
%532 = phi float* [ %525, %521 ], [ %577, %550 ]
%533 = icmp eq i64 %526, 0
br i1 %533, label %543, label %534
534: ; preds = %530, %534
%535 = phi float* [ %539, %534 ], [ %531, %530 ]
%536 = phi float* [ %540, %534 ], [ %532, %530 ]
%537 = phi i64 [ %541, %534 ], [ 0, %530 ]
%538 = load float, float* %536
%539 = getelementptr inbounds float, float* %535, i64 1
store float %538, float* %535
%540 = getelementptr inbounds float, float* %536, i64 %471
%541 = add i64 %537, 1
%542 = icmp eq i64 %541, %526
br i1 %542, label %543, label %534
543: ; preds = %534, %530
%544 = sub nsw i64 0, %523
%545 = getelementptr inbounds float, float* %525, i64 %544
%546 = and i64 %523, 1
%547 = icmp eq i64 %522, 0
br i1 %547, label %627, label %548
548: ; preds = %543
%549 = and i64 %523, 9223372036854775806
br label %580
550: ; preds = %550, %528
%551 = phi float* [ %30, %528 ], [ %576, %550 ]
%552 = phi float* [ %525, %528 ], [ %577, %550 ]
%553 = phi i64 [ 0, %528 ], [ %578, %550 ]
%554 = load float, float* %552
%555 = getelementptr inbounds float, float* %551, i64 1
store float %554, float* %551
%556 = getelementptr inbounds float, float* %552, i64 %471
%557 = load float, float* %556
%558 = getelementptr inbounds float, float* %551, i64 2
store float %557, float* %555
%559 = getelementptr inbounds float, float* %556, i64 %471
%560 = load float, float* %559
%561 = getelementptr inbounds float, float* %551, i64 3
store float %560, float* %558
%562 = getelementptr inbounds float, float* %559, i64 %471
%563 = load float, float* %562
%564 = getelementptr inbounds float, float* %551, i64 4
store float %563, float* %561
%565 = getelementptr inbounds float, float* %562, i64 %471
%566 = load float, float* %565
%567 = getelementptr inbounds float, float* %551, i64 5
store float %566, float* %564
%568 = getelementptr inbounds float, float* %565, i64 %471
%569 = load float, float* %568
%570 = getelementptr inbounds float, float* %551, i64 6
store float %569, float* %567
%571 = getelementptr inbounds float, float* %568, i64 %471
%572 = load float, float* %571
%573 = getelementptr inbounds float, float* %551, i64 7
store float %572, float* %570
%574 = getelementptr inbounds float, float* %571, i64 %471
%575 = load float, float* %574
%576 = getelementptr inbounds float, float* %551, i64 8
store float %575, float* %573
%577 = getelementptr inbounds float, float* %574, i64 %471
%578 = add i64 %553, 8
%579 = icmp eq i64 %578, %529
br i1 %579, label %530, label %550
580: ; preds = %623, %548
%581 = phi i64 [ 0, %548 ], [ %624, %623 ]
%582 = phi i64 [ 0, %548 ], [ %625, %623 ]
%583 = getelementptr inbounds float, float* %30, i64 %581
%584 = mul nsw i64 %581, %471
%585 = getelementptr inbounds float, float* %545, i64 %584
%586 = getelementptr inbounds float, float* %585, i64 %581
%587 = trunc i64 %581 to i32
br label %588
588: ; preds = %580, %588
%589 = phi i32 [ %599, %588 ], [ %587, %580 ]
%590 = phi float* [ %595, %588 ], [ %583, %580 ]
%591 = phi float* [ %593, %588 ], [ %586, %580 ]
%592 = phi float [ %598, %588 ], [ 0.000000e+00, %580 ]
%593 = getelementptr inbounds float, float* %591, i64 1
%594 = load float, float* %591
%595 = getelementptr inbounds float, float* %590, i64 1
%596 = load float, float* %590
%597 = fneg float %594
%598 = tail call float @llvm.fmuladd.f32(float %597, float %596, float %592)
%599 = add nuw nsw i32 %589, 1
%600 = zext i32 %599 to i64
%601 = icmp eq i64 %523, %600
br i1 %601, label %602, label %588
602: ; preds = %588
store float %598, float* %583
%603 = or i64 %581, 1
%604 = getelementptr inbounds float, float* %30, i64 %603
%605 = mul nsw i64 %603, %471
%606 = getelementptr inbounds float, float* %545, i64 %605
%607 = getelementptr inbounds float, float* %606, i64 %603
%608 = trunc i64 %603 to i32
br label %609
609: ; preds = %609, %602
%610 = phi i32 [ %620, %609 ], [ %608, %602 ]
%611 = phi float* [ %616, %609 ], [ %604, %602 ]
%612 = phi float* [ %614, %609 ], [ %607, %602 ]
%613 = phi float [ %619, %609 ], [ 0.000000e+00, %602 ]
%614 = getelementptr inbounds float, float* %612, i64 1
%615 = load float, float* %612
%616 = getelementptr inbounds float, float* %611, i64 1
%617 = load float, float* %611
%618 = fneg float %615
%619 = tail call float @llvm.fmuladd.f32(float %618, float %617, float %613)
%620 = add nuw nsw i32 %610, 1
%621 = zext i32 %620 to i64
%622 = icmp eq i64 %523, %621
br i1 %622, label %623, label %609
623: ; preds = %609
store float %619, float* %604
%624 = add nuw nsw i64 %581, 2
%625 = add i64 %582, 2
%626 = icmp eq i64 %625, %549
br i1 %626, label %627, label %580
627: ; preds = %623, %543
%628 = phi i64 [ 0, %543 ], [ %624, %623 ]
%629 = icmp eq i64 %546, 0
br i1 %629, label %651, label %630
630: ; preds = %627
%631 = getelementptr inbounds float, float* %30, i64 %628
%632 = mul nsw i64 %628, %471
%633 = getelementptr inbounds float, float* %545, i64 %632
%634 = getelementptr inbounds float, float* %633, i64 %628
%635 = trunc i64 %628 to i32
br label %636
636: ; preds = %636, %630
%637 = phi i32 [ %647, %636 ], [ %635, %630 ]
%638 = phi float* [ %643, %636 ], [ %631, %630 ]
%639 = phi float* [ %641, %636 ], [ %634, %630 ]
%640 = phi float [ %646, %636 ], [ 0.000000e+00, %630 ]
%641 = getelementptr inbounds float, float* %639, i64 1
%642 = load float, float* %639
%643 = getelementptr inbounds float, float* %638, i64 1
%644 = load float, float* %638
%645 = fneg float %642
%646 = tail call float @llvm.fmuladd.f32(float %645, float %644, float %640)
%647 = add nuw nsw i32 %637, 1
%648 = zext i32 %647 to i64
%649 = icmp eq i64 %523, %648
br i1 %649, label %650, label %636
650: ; preds = %636
store float %646, float* %631
br label %651
651: ; preds = %627, %650
%652 = and i64 %523, 7
%653 = icmp ult i64 %522, 7
br i1 %653, label %686, label %654
654: ; preds = %651
%655 = and i64 %523, 9223372036854775800
br label %656
656: ; preds = %656, %654
%657 = phi float* [ %30, %654 ], [ %681, %656 ]
%658 = phi float* [ %525, %654 ], [ %683, %656 ]
%659 = phi i64 [ 0, %654 ], [ %684, %656 ]
%660 = getelementptr inbounds float, float* %657, i64 1
%661 = load float, float* %657
store float %661, float* %658
%662 = getelementptr inbounds float, float* %658, i64 %471
%663 = getelementptr inbounds float, float* %657, i64 2
%664 = load float, float* %660
store float %664, float* %662
%665 = getelementptr inbounds float, float* %662, i64 %471
%666 = getelementptr inbounds float, float* %657, i64 3
%667 = load float, float* %663
store float %667, float* %665
%668 = getelementptr inbounds float, float* %665, i64 %471
%669 = getelementptr inbounds float, float* %657, i64 4
%670 = load float, float* %666
store float %670, float* %668
%671 = getelementptr inbounds float, float* %668, i64 %471
%672 = getelementptr inbounds float, float* %657, i64 5
%673 = load float, float* %669
store float %673, float* %671
%674 = getelementptr inbounds float, float* %671, i64 %471
%675 = getelementptr inbounds float, float* %657, i64 6
%676 = load float, float* %672
store float %676, float* %674
%677 = getelementptr inbounds float, float* %674, i64 %471
%678 = getelementptr inbounds float, float* %657, i64 7
%679 = load float, float* %675
store float %679, float* %677
%680 = getelementptr inbounds float, float* %677, i64 %471
%681 = getelementptr inbounds float, float* %657, i64 8
%682 = load float, float* %678
store float %682, float* %680
%683 = getelementptr inbounds float, float* %680, i64 %471
%684 = add i64 %659, 8
%685 = icmp eq i64 %684, %655
br i1 %685, label %686, label %656
686: ; preds = %656, %651
%687 = phi float* [ %30, %651 ], [ %681, %656 ]
%688 = phi float* [ %525, %651 ], [ %683, %656 ]
%689 = icmp eq i64 %652, 0
br i1 %689, label %699, label %690
690: ; preds = %686, %690
%691 = phi float* [ %694, %690 ], [ %687, %686 ]
%692 = phi float* [ %696, %690 ], [ %688, %686 ]
%693 = phi i64 [ %697, %690 ], [ 0, %686 ]
%694 = getelementptr inbounds float, float* %691, i64 1
%695 = load float, float* %691
store float %695, float* %692
%696 = getelementptr inbounds float, float* %692, i64 %471
%697 = add i64 %693, 1
%698 = icmp eq i64 %697, %652
br i1 %698, label %699, label %690
699: ; preds = %690, %686
%700 = add nuw nsw i64 %523, 1
%701 = icmp eq i64 %700, %472
%702 = add i64 %522, 1
br i1 %701, label %703, label %521
703: ; preds = %699
%704 = add i32 %1, -2
%705 = mul nsw i32 %1, %1
%706 = zext i32 %705 to i64
%707 = getelementptr inbounds float, float* %0, i64 %706
%708 = getelementptr inbounds float, float* %707, i64 -1
%709 = xor i32 %1, -1
%710 = sext i32 %709 to i64
%711 = sext i32 %1 to i64
%712 = add i32 %1, -1
%713 = sub nsw i64 0, %711
br label %726
714: ; preds = %915
%715 = sext i32 %1 to i64
%716 = zext i32 %712 to i64
%717 = zext i32 %1 to i64
%718 = and i32 %1, 7
%719 = icmp ult i32 %39, 7
%720 = and i32 %1, -8
%721 = icmp eq i32 %718, 0
%722 = and i32 %1, 7
%723 = icmp ult i32 %39, 7
%724 = and i32 %1, -8
%725 = icmp eq i32 %722, 0
br label %920
726: ; preds = %703, %915
%727 = phi i32 [ 0, %703 ], [ %919, %915 ]
%728 = phi i32 [ 1, %703 ], [ %917, %915 ]
%729 = phi i32 [ %704, %703 ], [ %916, %915 ]
%730 = phi float* [ %708, %703 ], [ %734, %915 ]
%731 = phi float* [ %708, %703 ], [ %733, %915 ]
%732 = sext i32 %728 to i64
%733 = getelementptr inbounds float, float* %731, i64 -1
%734 = getelementptr inbounds float, float* %730, i64 %710
%735 = xor i32 %729, -1
%736 = add i32 %735, %1
%737 = getelementptr inbounds float, float* %734, i64 %711
%738 = icmp sgt i32 %736, 0
br i1 %738, label %739, label %757
739: ; preds = %726
%740 = and i32 %728, 7
%741 = icmp ult i32 %727, 7
br i1 %741, label %744, label %742
742: ; preds = %739
%743 = and i32 %728, -8
br label %761
744: ; preds = %761, %739
%745 = phi float* [ %30, %739 ], [ %787, %761 ]
%746 = phi float* [ %737, %739 ], [ %788, %761 ]
%747 = icmp eq i32 %740, 0
br i1 %747, label %757, label %748
748: ; preds = %744, %748
%749 = phi float* [ %753, %748 ], [ %745, %744 ]
%750 = phi float* [ %754, %748 ], [ %746, %744 ]
%751 = phi i32 [ %755, %748 ], [ 0, %744 ]
%752 = load float, float* %750
%753 = getelementptr inbounds float, float* %749, i64 1
store float %752, float* %749
%754 = getelementptr inbounds float, float* %750, i64 %711
%755 = add i32 %751, 1
%756 = icmp eq i32 %755, %740
br i1 %756, label %757, label %748
757: ; preds = %744, %748, %726
%758 = icmp sgt i32 %712, %729
br i1 %758, label %759, label %791
759: ; preds = %757
%760 = add nsw i32 %729, 1
br label %797
761: ; preds = %761, %742
%762 = phi float* [ %30, %742 ], [ %787, %761 ]
%763 = phi float* [ %737, %742 ], [ %788, %761 ]
%764 = phi i32 [ 0, %742 ], [ %789, %761 ]
%765 = load float, float* %763
%766 = getelementptr inbounds float, float* %762, i64 1
store float %765, float* %762
%767 = getelementptr inbounds float, float* %763, i64 %711
%768 = load float, float* %767
%769 = getelementptr inbounds float, float* %762, i64 2
store float %768, float* %766
%770 = getelementptr inbounds float, float* %767, i64 %711
%771 = load float, float* %770
%772 = getelementptr inbounds float, float* %762, i64 3
store float %771, float* %769
%773 = getelementptr inbounds float, float* %770, i64 %711
%774 = load float, float* %773
%775 = getelementptr inbounds float, float* %762, i64 4
store float %774, float* %772
%776 = getelementptr inbounds float, float* %773, i64 %711
%777 = load float, float* %776
%778 = getelementptr inbounds float, float* %762, i64 5
store float %777, float* %775
%779 = getelementptr inbounds float, float* %776, i64 %711
%780 = load float, float* %779
%781 = getelementptr inbounds float, float* %762, i64 6
store float %780, float* %778
%782 = getelementptr inbounds float, float* %779, i64 %711
%783 = load float, float* %782
%784 = getelementptr inbounds float, float* %762, i64 7
store float %783, float* %781
%785 = getelementptr inbounds float, float* %782, i64 %711
%786 = load float, float* %785
%787 = getelementptr inbounds float, float* %762, i64 8
store float %786, float* %784
%788 = getelementptr inbounds float, float* %785, i64 %711
%789 = add i32 %764, 8
%790 = icmp eq i32 %789, %743
br i1 %790, label %744, label %761
791: ; preds = %864, %757
br i1 %738, label %792, label %915
792: ; preds = %791
%793 = and i32 %728, 7
%794 = icmp ult i32 %727, 7
br i1 %794, label %902, label %795
795: ; preds = %792
%796 = and i32 %728, -8
br label %872
797: ; preds = %759, %864
%798 = phi i32 [ 0, %759 ], [ %871, %864 ]
%799 = phi i64 [ %732, %759 ], [ %866, %864 ]
%800 = phi i32 [ %712, %759 ], [ %869, %864 ]
%801 = phi float* [ %733, %759 ], [ %868, %864 ]
%802 = xor i32 %798, -1
%803 = add i32 %727, %802
%804 = load float, float* %801
%805 = fneg float %804
%806 = icmp slt i32 %760, %800
br i1 %806, label %807, label %864
807: ; preds = %797
%808 = sub i32 %727, %798
%809 = and i32 %808, 3
%810 = icmp eq i32 %809, 0
br i1 %810, label %826, label %811
811: ; preds = %807, %811
%812 = phi i32 [ %823, %811 ], [ %760, %807 ]
%813 = phi float* [ %819, %811 ], [ %30, %807 ]
%814 = phi float* [ %817, %811 ], [ %801, %807 ]
%815 = phi float [ %822, %811 ], [ %805, %807 ]
%816 = phi i32 [ %824, %811 ], [ 0, %807 ]
%817 = getelementptr inbounds float, float* %814, i64 1
%818 = load float, float* %817
%819 = getelementptr inbounds float, float* %813, i64 1
%820 = load float, float* %813
%821 = fneg float %818
%822 = tail call float @llvm.fmuladd.f32(float %821, float %820, float %815)
%823 = add nsw i32 %812, 1
%824 = add i32 %816, 1
%825 = icmp eq i32 %824, %809
br i1 %825, label %826, label %811
826: ; preds = %811, %807
%827 = phi i32 [ %760, %807 ], [ %823, %811 ]
%828 = phi float* [ %30, %807 ], [ %819, %811 ]
%829 = phi float* [ %801, %807 ], [ %817, %811 ]
%830 = phi float [ %805, %807 ], [ %822, %811 ]
%831 = phi float [ undef, %807 ], [ %822, %811 ]
%832 = icmp ult i32 %803, 3
br i1 %832, label %864, label %833
833: ; preds = %826, %833
%834 = phi i32 [ %862, %833 ], [ %827, %826 ]
%835 = phi float* [ %858, %833 ], [ %828, %826 ]
%836 = phi float* [ %856, %833 ], [ %829, %826 ]
%837 = phi float [ %861, %833 ], [ %830, %826 ]
%838 = getelementptr inbounds float, float* %836, i64 1
%839 = load float, float* %838
%840 = getelementptr inbounds float, float* %835, i64 1
%841 = load float, float* %835
%842 = fneg float %839
%843 = tail call float @llvm.fmuladd.f32(float %842, float %841, float %837)
%844 = getelementptr inbounds float, float* %836, i64 2
%845 = load float, float* %844
%846 = getelementptr inbounds float, float* %835, i64 2
%847 = load float, float* %840
%848 = fneg float %845
%849 = tail call float @llvm.fmuladd.f32(float %848, float %847, float %843)
%850 = getelementptr inbounds float, float* %836, i64 3
%851 = load float, float* %850
%852 = getelementptr inbounds float, float* %835, i64 3
%853 = load float, float* %846
%854 = fneg float %851
%855 = tail call float @llvm.fmuladd.f32(float %854, float %853, float %849)
%856 = getelementptr inbounds float, float* %836, i64 4
%857 = load float, float* %856
%858 = getelementptr inbounds float, float* %835, i64 4
%859 = load float, float* %852
%860 = fneg float %857
%861 = tail call float @llvm.fmuladd.f32(float %860, float %859, float %855)
%862 = add nsw i32 %834, 4
%863 = icmp slt i32 %862, %800
br i1 %863, label %833, label %864
864: ; preds = %826, %833, %797
%865 = phi float [ %805, %797 ], [ %831, %826 ], [ %861, %833 ]
%866 = add nsw i64 %799, -1
%867 = getelementptr inbounds float, float* %30, i64 %866
store float %865, float* %867
%868 = getelementptr inbounds float, float* %801, i64 %713
%869 = add nsw i32 %800, -1
%870 = icmp sgt i32 %869, %729
%871 = add i32 %798, 1
br i1 %870, label %797, label %791
872: ; preds = %872, %795
%873 = phi float* [ %30, %795 ], [ %897, %872 ]
%874 = phi float* [ %737, %795 ], [ %899, %872 ]
%875 = phi i32 [ 0, %795 ], [ %900, %872 ]
%876 = getelementptr inbounds float, float* %873, i64 1
%877 = load float, float* %873
store float %877, float* %874
%878 = getelementptr inbounds float, float* %874, i64 %711
%879 = getelementptr inbounds float, float* %873, i64 2
%880 = load float, float* %876
store float %880, float* %878
%881 = getelementptr inbounds float, float* %878, i64 %711
%882 = getelementptr inbounds float, float* %873, i64 3
%883 = load float, float* %879
store float %883, float* %881
%884 = getelementptr inbounds float, float* %881, i64 %711
%885 = getelementptr inbounds float, float* %873, i64 4
%886 = load float, float* %882
store float %886, float* %884
%887 = getelementptr inbounds float, float* %884, i64 %711
%888 = getelementptr inbounds float, float* %873, i64 5
%889 = load float, float* %885
store float %889, float* %887
%890 = getelementptr inbounds float, float* %887, i64 %711
%891 = getelementptr inbounds float, float* %873, i64 6
%892 = load float, float* %888
store float %892, float* %890
%893 = getelementptr inbounds float, float* %890, i64 %711
%894 = getelementptr inbounds float, float* %873, i64 7
%895 = load float, float* %891
store float %895, float* %893
%896 = getelementptr inbounds float, float* %893, i64 %711
%897 = getelementptr inbounds float, float* %873, i64 8
%898 = load float, float* %894
store float %898, float* %896
%899 = getelementptr inbounds float, float* %896, i64 %711
%900 = add i32 %875, 8
%901 = icmp eq i32 %900, %796
br i1 %901, label %902, label %872
902: ; preds = %872, %792
%903 = phi float* [ %30, %792 ], [ %897, %872 ]
%904 = phi float* [ %737, %792 ], [ %899, %872 ]
%905 = icmp eq i32 %793, 0
br i1 %905, label %915, label %906
906: ; preds = %902, %906
%907 = phi float* [ %910, %906 ], [ %903, %902 ]
%908 = phi float* [ %912, %906 ], [ %904, %902 ]
%909 = phi i32 [ %913, %906 ], [ 0, %902 ]
%910 = getelementptr inbounds float, float* %907, i64 1
%911 = load float, float* %907
store float %911, float* %908
%912 = getelementptr inbounds float, float* %908, i64 %711
%913 = add i32 %909, 1
%914 = icmp eq i32 %913, %793
br i1 %914, label %915, label %906
915: ; preds = %902, %906, %791
%916 = add nsw i32 %729, -1
%917 = add nuw i32 %728, 1
%918 = icmp eq i32 %917, %1
%919 = add i32 %727, 1
br i1 %918, label %714, label %726
920: ; preds = %1089, %714
%921 = phi i64 [ 0, %714 ], [ %1090, %1089 ]
%922 = phi float* [ %0, %714 ], [ %1091, %1089 ]
br i1 %719, label %923, label %938
923: ; preds = %938, %920
%924 = phi float* [ %30, %920 ], [ %964, %938 ]
%925 = phi float* [ %922, %920 ], [ %965, %938 ]
br i1 %721, label %935, label %926
926: ; preds = %923, %926
%927 = phi float* [ %931, %926 ], [ %924, %923 ]
%928 = phi float* [ %932, %926 ], [ %925, %923 ]
%929 = phi i32 [ %933, %926 ], [ 0, %923 ]
%930 = load float, float* %928
%931 = getelementptr inbounds float, float* %927, i64 1
store float %930, float* %927
%932 = getelementptr inbounds float, float* %928, i64 %715
%933 = add i32 %929, 1
%934 = icmp eq i32 %933, %718
br i1 %934, label %935, label %926
935: ; preds = %926, %923
%936 = trunc i64 %921 to i32
%937 = add i32 %936, 1
br label %968
938: ; preds = %920, %938
%939 = phi float* [ %964, %938 ], [ %30, %920 ]
%940 = phi float* [ %965, %938 ], [ %922, %920 ]
%941 = phi i32 [ %966, %938 ], [ 0, %920 ]
%942 = load float, float* %940
%943 = getelementptr inbounds float, float* %939, i64 1
store float %942, float* %939
%944 = getelementptr inbounds float, float* %940, i64 %715
%945 = load float, float* %944
%946 = getelementptr inbounds float, float* %939, i64 2
store float %945, float* %943
%947 = getelementptr inbounds float, float* %944, i64 %715
%948 = load float, float* %947
%949 = getelementptr inbounds float, float* %939, i64 3
store float %948, float* %946
%950 = getelementptr inbounds float, float* %947, i64 %715
%951 = load float, float* %950
%952 = getelementptr inbounds float, float* %939, i64 4
store float %951, float* %949
%953 = getelementptr inbounds float, float* %950, i64 %715
%954 = load float, float* %953
%955 = getelementptr inbounds float, float* %939, i64 5
store float %954, float* %952
%956 = getelementptr inbounds float, float* %953, i64 %715
%957 = load float, float* %956
%958 = getelementptr inbounds float, float* %939, i64 6
store float %957, float* %955
%959 = getelementptr inbounds float, float* %956, i64 %715
%960 = load float, float* %959
%961 = getelementptr inbounds float, float* %939, i64 7
store float %960, float* %958
%962 = getelementptr inbounds float, float* %959, i64 %715
%963 = load float, float* %962
%964 = getelementptr inbounds float, float* %939, i64 8
store float %963, float* %961
%965 = getelementptr inbounds float, float* %962, i64 %715
%966 = add i32 %941, 8
%967 = icmp eq i32 %966, %720
br i1 %967, label %923, label %938
968: ; preds = %935, %1040
%969 = phi i64 [ 0, %935 ], [ %1043, %1040 ]
%970 = phi float* [ %0, %935 ], [ %1044, %1040 ]
%971 = icmp ugt i64 %969, %921
br i1 %971, label %972, label %975
972: ; preds = %968
%973 = getelementptr inbounds float, float* %970, i64 %969
%974 = trunc i64 %969 to i32
br label %980
975: ; preds = %968
%976 = getelementptr inbounds float, float* %30, i64 %969
%977 = load float, float* %976
%978 = getelementptr inbounds float, float* %970, i64 %921
%979 = getelementptr inbounds float, float* %978, i64 1
br label %980
980: ; preds = %975, %972
%981 = phi float [ 0.000000e+00, %972 ], [ %977, %975 ]
%982 = phi float* [ %973, %972 ], [ %979, %975 ]
%983 = phi i32 [ %974, %972 ], [ %937, %975 ]
%984 = icmp slt i32 %983, %1
br i1 %984, label %985, label %1040
985: ; preds = %980
%986 = zext i32 %983 to i64
%987 = sub nsw i64 %38, %986
%988 = xor i64 %986, -1
%989 = add nsw i64 %988, %38
%990 = and i64 %987, 3
%991 = icmp eq i64 %990, 0
br i1 %991, label %1005, label %992
992: ; preds = %985, %992
%993 = phi i64 [ %999, %992 ], [ %986, %985 ]
%994 = phi float* [ %997, %992 ], [ %982, %985 ]
%995 = phi float [ %1002, %992 ], [ %981, %985 ]
%996 = phi i64 [ %1003, %992 ], [ 0, %985 ]
%997 = getelementptr inbounds float, float* %994, i64 1
%998 = load float, float* %994
%999 = add nuw nsw i64 %993, 1
%1000 = getelementptr inbounds float, float* %30, i64 %993
%1001 = load float, float* %1000
%1002 = tail call float @llvm.fmuladd.f32(float %998, float %1001, float %995)
%1003 = add i64 %996, 1
%1004 = icmp eq i64 %1003, %990
br i1 %1004, label %1005, label %992
1005: ; preds = %992, %985
%1006 = phi float [ undef, %985 ], [ %1002, %992 ]
%1007 = phi i64 [ %986, %985 ], [ %999, %992 ]
%1008 = phi float* [ %982, %985 ], [ %997, %992 ]
%1009 = phi float [ %981, %985 ], [ %1002, %992 ]
%1010 = icmp ult i64 %989, 3
br i1 %1010, label %1040, label %1011
1011: ; preds = %1005, %1011
%1012 = phi i64 [ %1035, %1011 ], [ %1007, %1005 ]
%1013 = phi float* [ %1033, %1011 ], [ %1008, %1005 ]
%1014 = phi float [ %1038, %1011 ], [ %1009, %1005 ]
%1015 = getelementptr inbounds float, float* %1013, i64 1
%1016 = load float, float* %1013
%1017 = add nuw nsw i64 %1012, 1
%1018 = getelementptr inbounds float, float* %30, i64 %1012
%1019 = load float, float* %1018
%1020 = tail call float @llvm.fmuladd.f32(float %1016, float %1019, float %1014)
%1021 = getelementptr inbounds float, float* %1013, i64 2
%1022 = load float, float* %1015
%1023 = add nuw nsw i64 %1012, 2
%1024 = getelementptr inbounds float, float* %30, i64 %1017
%1025 = load float, float* %1024
%1026 = tail call float @llvm.fmuladd.f32(float %1022, float %1025, float %1020)
%1027 = getelementptr inbounds float, float* %1013, i64 3
%1028 = load float, float* %1021
%1029 = add nuw nsw i64 %1012, 3
%1030 = getelementptr inbounds float, float* %30, i64 %1023
%1031 = load float, float* %1030
%1032 = tail call float @llvm.fmuladd.f32(float %1028, float %1031, float %1026)
%1033 = getelementptr inbounds float, float* %1013, i64 4
%1034 = load float, float* %1027
%1035 = add nuw nsw i64 %1012, 4
%1036 = getelementptr inbounds float, float* %30, i64 %1029
%1037 = load float, float* %1036
%1038 = tail call float @llvm.fmuladd.f32(float %1034, float %1037, float %1032)
%1039 = icmp eq i64 %1035, %717
br i1 %1039, label %1040, label %1011
1040: ; preds = %1005, %1011, %980
%1041 = phi float [ %981, %980 ], [ %1006, %1005 ], [ %1038, %1011 ]
%1042 = getelementptr inbounds float, float* %30, i64 %969
store float %1041, float* %1042
%1043 = add nuw nsw i64 %969, 1
%1044 = getelementptr inbounds float, float* %970, i64 %715
%1045 = icmp eq i64 %1043, %717
br i1 %1045, label %1046, label %968
1046: ; preds = %1040
br i1 %723, label %1077, label %1047
1047: ; preds = %1046, %1047
%1048 = phi float* [ %1072, %1047 ], [ %30, %1046 ]
%1049 = phi float* [ %1074, %1047 ], [ %922, %1046 ]
%1050 = phi i32 [ %1075, %1047 ], [ 0, %1046 ]
%1051 = getelementptr inbounds float, float* %1048, i64 1
%1052 = load float, float* %1048
store float %1052, float* %1049
%1053 = getelementptr inbounds float, float* %1049, i64 %715
%1054 = getelementptr inbounds float, float* %1048, i64 2
%1055 = load float, float* %1051
store float %1055, float* %1053
%1056 = getelementptr inbounds float, float* %1053, i64 %715
%1057 = getelementptr inbounds float, float* %1048, i64 3
%1058 = load float, float* %1054
store float %1058, float* %1056
%1059 = getelementptr inbounds float, float* %1056, i64 %715
%1060 = getelementptr inbounds float, float* %1048, i64 4
%1061 = load float, float* %1057
store float %1061, float* %1059
%1062 = getelementptr inbounds float, float* %1059, i64 %715
%1063 = getelementptr inbounds float, float* %1048, i64 5
%1064 = load float, float* %1060
store float %1064, float* %1062
%1065 = getelementptr inbounds float, float* %1062, i64 %715
%1066 = getelementptr inbounds float, float* %1048, i64 6
%1067 = load float, float* %1063
store float %1067, float* %1065
%1068 = getelementptr inbounds float, float* %1065, i64 %715
%1069 = getelementptr inbounds float, float* %1048, i64 7
%1070 = load float, float* %1066
store float %1070, float* %1068
%1071 = getelementptr inbounds float, float* %1068, i64 %715
%1072 = getelementptr inbounds float, float* %1048, i64 8
%1073 = load float, float* %1069
store float %1073, float* %1071
%1074 = getelementptr inbounds float, float* %1071, i64 %715
%1075 = add i32 %1050, 8
%1076 = icmp eq i32 %1075, %724
br i1 %1076, label %1077, label %1047
1077: ; preds = %1047, %1046
%1078 = phi float* [ %30, %1046 ], [ %1072, %1047 ]
%1079 = phi float* [ %922, %1046 ], [ %1074, %1047 ]
br i1 %725, label %1089, label %1080
1080: ; preds = %1077, %1080
%1081 = phi float* [ %1084, %1080 ], [ %1078, %1077 ]
%1082 = phi float* [ %1086, %1080 ], [ %1079, %1077 ]
%1083 = phi i32 [ %1087, %1080 ], [ 0, %1077 ]
%1084 = getelementptr inbounds float, float* %1081, i64 1
%1085 = load float, float* %1081
store float %1085, float* %1082
%1086 = getelementptr inbounds float, float* %1082, i64 %715
%1087 = add i32 %1083, 1
%1088 = icmp eq i32 %1087, %722
br i1 %1088, label %1089, label %1080
1089: ; preds = %1080, %1077
%1090 = add nuw nsw i64 %921, 1
%1091 = getelementptr inbounds float, float* %922, i64 1
%1092 = icmp eq i64 %1090, %716
br i1 %1092, label %1093, label %920
1093: ; preds = %1089
%1094 = sext i32 %1 to i64
%1095 = zext i32 %704 to i64
%1096 = and i32 %1, 3
%1097 = icmp ult i32 %39, 3
%1098 = and i32 %1, -4
%1099 = icmp eq i32 %1096, 0
br label %1100
1100: ; preds = %1143, %1093
%1101 = phi i64 [ %1095, %1093 ], [ %1144, %1143 ]
%1102 = phi i32* [ %77, %1093 ], [ %1103, %1143 ]
%1103 = getelementptr inbounds i32, i32* %1102, i64 -1
%1104 = load i32, i32* %1103
%1105 = sext i32 %1104 to i64
%1106 = getelementptr inbounds float, float* %0, i64 %1105
%1107 = getelementptr inbounds float, float* %0, i64 %1101
br i1 %1097, label %1130, label %1108
1108: ; preds = %1100, %1108
%1109 = phi float* [ %1127, %1108 ], [ %1106, %1100 ]
%1110 = phi float* [ %1126, %1108 ], [ %1107, %1100 ]
%1111 = phi i32 [ %1128, %1108 ], [ 0, %1100 ]
%1112 = load float, float* %1110
%1113 = load float, float* %1109
store float %1113, float* %1110
store float %1112, float* %1109
%1114 = getelementptr inbounds float, float* %1110, i64 %1094
%1115 = getelementptr inbounds float, float* %1109, i64 %1094
%1116 = load float, float* %1114
%1117 = load float, float* %1115
store float %1117, float* %1114
store float %1116, float* %1115
%1118 = getelementptr inbounds float, float* %1114, i64 %1094
%1119 = getelementptr inbounds float, float* %1115, i64 %1094
%1120 = load float, float* %1118
%1121 = load float, float* %1119
store float %1121, float* %1118
store float %1120, float* %1119
%1122 = getelementptr inbounds float, float* %1118, i64 %1094
%1123 = getelementptr inbounds float, float* %1119, i64 %1094
%1124 = load float, float* %1122
%1125 = load float, float* %1123
store float %1125, float* %1122
store float %1124, float* %1123
%1126 = getelementptr inbounds float, float* %1122, i64 %1094
%1127 = getelementptr inbounds float, float* %1123, i64 %1094
%1128 = add i32 %1111, 4
%1129 = icmp eq i32 %1128, %1098
br i1 %1129, label %1130, label %1108
1130: ; preds = %1108, %1100
%1131 = phi float* [ %1106, %1100 ], [ %1127, %1108 ]
%1132 = phi float* [ %1107, %1100 ], [ %1126, %1108 ]
br i1 %1099, label %1143, label %1133
1133: ; preds = %1130, %1133
%1134 = phi float* [ %1140, %1133 ], [ %1131, %1130 ]
%1135 = phi float* [ %1139, %1133 ], [ %1132, %1130 ]
%1136 = phi i32 [ %1141, %1133 ], [ 0, %1130 ]
%1137 = load float, float* %1135
%1138 = load float, float* %1134
store float %1138, float* %1135
store float %1137, float* %1134
%1139 = getelementptr inbounds float, float* %1135, i64 %1094
%1140 = getelementptr inbounds float, float* %1134, i64 %1094
%1141 = add i32 %1136, 1
%1142 = icmp eq i32 %1141, %1096
br i1 %1142, label %1143, label %1133
1143: ; preds = %1133, %1130
%1144 = add nsw i64 %1101, -1
%1145 = icmp sgt i64 %1101, 0
br i1 %1145, label %1100, label %1146
1146: ; preds = %293, %1143, %66, %29, %469
%1147 = phi i32 [ 0, %469 ], [ 0, %29 ], [ 0, %66 ], [ 0, %1143 ], [ -1, %293 ]
ret i32 %1147
}