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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
float fabs(float);
float **fmatrix(int, int, int, int);
int /*<<< orphan*/ free_fmatrix(float **, int, int, int, int);
int /*<<< orphan*/ free_fvector(float *, int);
float *fvector(int, int);
int /*<<< orphan*/ gauss(float **, float *, int, int *, float *);
int /*<<< orphan*/ minmax(float *, int, float *, float *);
float sqrt(float);
void itrpl2(float *y, float *z, int npts, int nterms, float u, float v,
            float sfac, float bfac, int *ier) {
  float sighigh = 1.e2, sigmin = 0.01;
  float ynorm, ysum, fnpi, sigma0, sigma1, absy, w, xi, yi, xterm, yterm, ybas,
      rj, rjj;
  float *a, *sumx, *sumy, *r, **aug, rnorm;
  int i, j, k, n, nmax, ntp1, icnt, nsum;
  int mcnt = 100;
  int lstop = 0;
  if (nterms <= 0) {
    return;
  }
  y--;
  if (z)
    z--;
  minmax(y + 1, npts, &ysum, &ynorm);
  ysum = fabs(ysum);
  ynorm = fabs(ynorm);
  if (ysum > ynorm)
    ynorm = ysum;
  if (ynorm == 0)
    return;
  ynorm = 1.0 / ynorm;
  for (j = 1; j <= npts; j++)
    y[j] *= ynorm;
  fnpi = 1.0 / (float)npts;
  nmax = 2 * nterms - 1;
  ntp1 = nterms + 1;
  a = fvector(1, nterms);
  sumx = fvector(1, nmax);
  sumy = fvector(1, nterms);
  r = fvector(1, nterms);
  aug = fmatrix(1, ntp1, 1, nterms);
  icnt = 0;
  sigma1 = sighigh;
  while (!lstop) {
    icnt++;
    if (icnt >= mcnt) {
      if (z)
        *ier += 2000;
      else
        *ier += 1000;
      break;
    }
    sigma0 = sigma1;
    nsum = 1;
    ysum = 0.0;
    for (j = 1; j <= npts; j++) {
      absy = fabs(y[j]);
      if ((u * sigma0) < absy)
        continue;
      nsum++;
      ysum += absy * absy;
    }
    sigma1 = sqrt(ysum / nsum);
    if (ysum == 0.0)
      sigma1 = sigmin;
    if ((sigma0 - sigma1) / sigma0 > sfac)
      continue;
    w = v * sigma1;
    for (n = 1; n <= nmax; n++)
      sumx[n] = 0.0;
    for (j = 1; j <= nterms; j++)
      sumy[j] = 0.0;
    for (i = 1; i <= npts; i++) {
      yi = y[i];
      if (!z && fabs(yi) > w)
        continue;
      if (z && z[i] == 0.0)
        continue;
      xi = (float)i * fnpi;
      xterm = 1.0;
      for (n = 1; n <= nmax; n++) {
        sumx[n] += xterm;
        xterm *= xi;
      }
      yterm = yi;
      for (n = 1; n <= nterms; n++) {
        sumy[n] += yterm;
        yterm *= xi;
      }
    }
    for (j = 1; j <= nterms; j++) {
      for (k = 1; k <= nterms; k++) {
        n = j + k - 1;
        aug[k][j] = sumx[n];
      }
      aug[ntp1][j] = sumy[j];
    }
    gauss(aug, a, nterms, ier, &rnorm);
    lstop = 1;
    if (*ier != 1) {
      if (z)
        *ier += 2000;
      else
        *ier += 1000;
      break;
    }
    for (j = 1; j <= npts; j++) {
      ybas = a[1];
      rj = (float)j * fnpi;
      rjj = 1.0;
      for (k = 2; k <= nterms; k++) {
        rjj *= rj;
        ybas += a[k] * rjj;
      }
      y[j] -= ybas;
      if (fabs(ybas) > bfac * sigma1)
        lstop = 0;
    }
  }
  ynorm = 1.0 / ynorm;
  for (j = 1; j <= npts; j++)
    y[j] *= ynorm;
  free_fvector(a, 1);
  free_fvector(sumx, 1);
  free_fvector(sumy, 1);
  free_fvector(r, 1);
  free_fmatrix(aug, 1, ntp1, 1, nterms);
}


x86 assembly (clang, -O0):
<itrpl2>:
push   %rbp
mov    %rsp,%rbp
sub    $0xd0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %ecx,-0x18(%rbp)
movss  %xmm0,-0x1c(%rbp)
movss  %xmm1,-0x20(%rbp)
movss  %xmm2,-0x24(%rbp)
movss  %xmm3,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
movss  0xe4b(%rip),%xmm0
movss  %xmm0,-0x34(%rbp)
movss  0xe3a(%rip),%xmm0
movss  %xmm0,-0x38(%rbp)
movl   $0x64,-0xc0(%rbp)
movl   $0x0,-0xc4(%rbp)
cmpl   $0x0,-0x18(%rbp)
jg     11ee <itrpl2+0x6e>
jmp    1a1e <itrpl2+0x89e>
mov    -0x8(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x8(%rbp)
cmpq   $0x0,-0x10(%rbp)
je     1211 <itrpl2+0x91>
mov    -0x10(%rbp),%rax
add    $0xfffffffffffffffc,%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rdi
add    $0x4,%rdi
mov    -0x14(%rbp),%esi
lea    -0x40(%rbp),%rdx
lea    -0x3c(%rbp),%rcx
call   10a0 <minmax@plt>
movss  -0x40(%rbp),%xmm0
call   1060 <fabs@plt>
movss  %xmm0,-0x40(%rbp)
movss  -0x3c(%rbp),%xmm0
call   1060 <fabs@plt>
movss  %xmm0,-0x3c(%rbp)
movss  -0x40(%rbp),%xmm0
ucomiss -0x3c(%rbp),%xmm0
jbe    1260 <itrpl2+0xe0>
movss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    127c <itrpl2+0xfc>
jp     127c <itrpl2+0xfc>
jmp    1a1e <itrpl2+0x89e>
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd83(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x1,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     12e1 <itrpl2+0x161>
movss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    12a4 <itrpl2+0x124>
cvtsi2ssl -0x14(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd1e(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x1,%eax
sub    $0x1,%eax
mov    %eax,-0xb0(%rbp)
mov    -0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb4(%rbp)
mov    -0x18(%rbp),%esi
mov    $0x1,%edi
call   1070 <fvector@plt>
mov    %rax,-0x78(%rbp)
mov    -0xb0(%rbp),%esi
mov    $0x1,%edi
call   1070 <fvector@plt>
mov    %rax,-0x80(%rbp)
mov    -0x18(%rbp),%esi
mov    $0x1,%edi
call   1070 <fvector@plt>
mov    %rax,-0x88(%rbp)
mov    -0x18(%rbp),%esi
mov    $0x1,%edi
call   1070 <fvector@plt>
mov    %rax,-0x90(%rbp)
mov    -0xb4(%rbp),%esi
mov    -0x18(%rbp),%ecx
mov    $0x1,%edx
mov    %edx,%edi
call   1080 <fmatrix@plt>
mov    %rax,-0x98(%rbp)
movl   $0x0,-0xb8(%rbp)
movss  -0x34(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
cmpl   $0x0,-0xc4(%rbp)
setne  %al
xor    $0xff,%al
test   $0x1,%al
jne    13b0 <itrpl2+0x230>
jmp    195e <itrpl2+0x7de>
mov    -0xb8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xb8(%rbp)
mov    -0xb8(%rbp),%eax
cmp    -0xc0(%rbp),%eax
jl     1402 <itrpl2+0x282>
cmpq   $0x0,-0x10(%rbp)
je     13ef <itrpl2+0x26f>
mov    -0x30(%rbp),%rax
mov    (%rax),%ecx
add    $0x7d0,%ecx
mov    %ecx,(%rax)
jmp    13fd <itrpl2+0x27d>
mov    -0x30(%rbp),%rax
mov    (%rax),%ecx
add    $0x3e8,%ecx
mov    %ecx,(%rax)
jmp    195e <itrpl2+0x7de>
movss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
movl   $0x1,-0xbc(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x40(%rbp)
movl   $0x1,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     14ad <itrpl2+0x32d>
mov    -0x8(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
call   1060 <fabs@plt>
movss  %xmm0,-0x50(%rbp)
movss  -0x1c(%rbp),%xmm1
mulss  -0x48(%rbp),%xmm1
movss  -0x50(%rbp),%xmm0
ucomiss %xmm1,%xmm0
jbe    146e <itrpl2+0x2ee>
jmp    1499 <itrpl2+0x319>
mov    -0xbc(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xbc(%rbp)
movss  -0x50(%rbp),%xmm0
movss  -0x50(%rbp),%xmm2
movss  -0x40(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x40(%rbp)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1428 <itrpl2+0x2a8>
movss  -0x40(%rbp),%xmm0
cvtsi2ssl -0xbc(%rbp),%xmm1
ff
divss  %xmm1,%xmm0
call   1090 <sqrt@plt>
movss  %xmm0,-0x4c(%rbp)
movss  -0x40(%rbp),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14ee <itrpl2+0x36e>
jp     14ee <itrpl2+0x36e>
movss  -0x38(%rbp),%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x48(%rbp),%xmm0
subss  -0x4c(%rbp),%xmm0
divss  -0x48(%rbp),%xmm0
ucomiss -0x24(%rbp),%xmm0
jbe    150c <itrpl2+0x38c>
jmp    1397 <itrpl2+0x217>
movss  -0x20(%rbp),%xmm0
mulss  -0x4c(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
movl   $0x1,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jg     155e <itrpl2+0x3de>
mov    -0x80(%rbp),%rax
movslq -0xac(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1525 <itrpl2+0x3a5>
movl   $0x1,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     15a1 <itrpl2+0x421>
mov    -0x88(%rbp),%rax
movslq -0xa4(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1568 <itrpl2+0x3e8>
movl   $0x1,-0xa0(%rbp)
mov    -0xa0(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     171e <itrpl2+0x59e>
mov    -0x8(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x5c(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    15f3 <itrpl2+0x473>
movss  -0x5c(%rbp),%xmm0
call   1060 <fabs@plt>
ucomiss -0x54(%rbp),%xmm0
jbe    15f3 <itrpl2+0x473>
jmp    170a <itrpl2+0x58a>
cmpq   $0x0,-0x10(%rbp)
je     162a <itrpl2+0x4aa>
mov    -0x10(%rbp),%rax
movslq -0xa0(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    162a <itrpl2+0x4aa>
jp     162a <itrpl2+0x4aa>
jmp    170a <itrpl2+0x58a>
cvtsi2ssl -0xa0(%rbp),%xmm0
ff
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x58(%rbp)
movss  0x9c4(%rip),%xmm0
movss  %xmm0,-0x60(%rbp)
movl   $0x1,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0xb0(%rbp),%eax
jg     16a2 <itrpl2+0x522>
movss  -0x60(%rbp),%xmm0
mov    -0x80(%rbp),%rax
movslq -0xac(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mulss  -0x60(%rbp),%xmm0
movss  %xmm0,-0x60(%rbp)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1653 <itrpl2+0x4d3>
movss  -0x5c(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
movl   $0x1,-0xac(%rbp)
mov    -0xac(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     1705 <itrpl2+0x585>
movss  -0x64(%rbp),%xmm0
mov    -0x88(%rbp),%rax
movslq -0xac(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x58(%rbp),%xmm0
mulss  -0x64(%rbp),%xmm0
movss  %xmm0,-0x64(%rbp)
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    16b6 <itrpl2+0x536>
jmp    170a <itrpl2+0x58a>
mov    -0xa0(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa0(%rbp)
jmp    15ab <itrpl2+0x42b>
movl   $0x1,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     17ec <itrpl2+0x66c>
movl   $0x1,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     17a7 <itrpl2+0x627>
mov    -0xa4(%rbp),%eax
add    -0xa8(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0xac(%rbp)
mov    -0x80(%rbp),%rax
movslq -0xac(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x98(%rbp),%rax
movslq -0xa8(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    1741 <itrpl2+0x5c1>
mov    -0x88(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x98(%rbp),%rax
movslq -0xb4(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0xa4(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1728 <itrpl2+0x5a8>
mov    -0x98(%rbp),%rdi
mov    -0x78(%rbp),%rsi
mov    -0x18(%rbp),%edx
mov    -0x30(%rbp),%rcx
lea    -0x9c(%rbp),%r8
call   1030 <gauss@plt>
movl   $0x1,-0xc4(%rbp)
mov    -0x30(%rbp),%rax
cmpl   $0x1,(%rax)
je     1852 <itrpl2+0x6d2>
cmpq   $0x0,-0x10(%rbp)
je     183f <itrpl2+0x6bf>
mov    -0x30(%rbp),%rax
mov    (%rax),%ecx
add    $0x7d0,%ecx
mov    %ecx,(%rax)
jmp    184d <itrpl2+0x6cd>
mov    -0x30(%rbp),%rax
mov    (%rax),%ecx
add    $0x3e8,%ecx
mov    %ecx,(%rax)
jmp    195e <itrpl2+0x7de>
movl   $0x1,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1959 <itrpl2+0x7d9>
mov    -0x78(%rbp),%rax
movss  0x4(%rax),%xmm0
movss  %xmm0,-0x68(%rbp)
cvtsi2ssl -0xa4(%rbp),%xmm0
ff
mulss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x6c(%rbp)
movss  0x775(%rip),%xmm0
movss  %xmm0,-0x70(%rbp)
movl   $0x2,-0xa8(%rbp)
mov    -0xa8(%rbp),%eax
cmp    -0x18(%rbp),%eax
jg     18fb <itrpl2+0x77b>
movss  -0x6c(%rbp),%xmm0
mulss  -0x70(%rbp),%xmm0
movss  %xmm0,-0x70(%rbp)
mov    -0x78(%rbp),%rax
movslq -0xa8(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x70(%rbp),%xmm2
movss  -0x68(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x68(%rbp)
mov    -0xa8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa8(%rbp)
jmp    18a2 <itrpl2+0x722>
movss  -0x68(%rbp),%xmm1
mov    -0x8(%rbp),%rax
movslq -0xa4(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  -0x68(%rbp),%xmm0
call   1060 <fabs@plt>
movss  -0x28(%rbp),%xmm1
mulss  -0x4c(%rbp),%xmm1
ucomiss %xmm1,%xmm0
jbe    1940 <itrpl2+0x7c0>
movl   $0x0,-0xc4(%rbp)
jmp    1945 <itrpl2+0x7c5>
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    185c <itrpl2+0x6dc>
jmp    1397 <itrpl2+0x217>
movss  -0x3c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0x6a1(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x3c(%rbp)
movl   $0x1,-0xa4(%rbp)
mov    -0xa4(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     19c3 <itrpl2+0x843>
movss  -0x3c(%rbp),%xmm0
mov    -0x8(%rbp),%rax
movslq -0xa4(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0xa4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xa4(%rbp)
jmp    1986 <itrpl2+0x806>
mov    -0x78(%rbp),%rdi
mov    $0x1,%esi
call   1040 <free_fvector@plt>
mov    -0x80(%rbp),%rdi
mov    $0x1,%esi
call   1040 <free_fvector@plt>
mov    -0x88(%rbp),%rdi
mov    $0x1,%esi
call   1040 <free_fvector@plt>
mov    -0x90(%rbp),%rdi
mov    $0x1,%esi
call   1040 <free_fvector@plt>
mov    -0x98(%rbp),%rdi
mov    -0xb4(%rbp),%edx
mov    -0x18(%rbp),%r8d
mov    $0x1,%ecx
mov    %ecx,%esi
call   1050 <free_fmatrix@plt>
add    $0xd0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<itrpl2>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x128,%rsp
movss  %xmm3,0x58(%rsp)
movss  %xmm2,0x64(%rsp)
movss  %xmm1,0x54(%rsp)
movss  %xmm0,0x60(%rsp)
test   %ecx,%ecx
jle    1d45 <itrpl2+0xbc5>
mov    %r8,%r14
mov    %ecx,%r15d
mov    %edx,%eax
mov    %rsi,%rbx
mov    %rdi,%rbp
lea    -0x4(%rsi),%r12
test   %rsi,%rsi
cmove  %rsi,%r12
lea    0x4(%rsp),%rdx
lea    0x10(%rsp),%rcx
mov    %eax,%esi
mov    %rax,0x18(%rsp)
mov    %rbx,0x48(%rsp)
call   10a0 <minmax@plt>
mov    0x18(%rsp),%rsi
movss  0x4(%rsp),%xmm1
movaps 0xe09(%rip),%xmm2
andps  %xmm2,%xmm1
movss  %xmm1,0x4(%rsp)
movss  0x10(%rsp),%xmm0
andps  %xmm2,%xmm0
maxss  %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomiss %xmm0,%xmm1
jne    121b <itrpl2+0x9b>
jnp    1d45 <itrpl2+0xbc5>
mov    %r12,0xe8(%rsp)
movss  0xde5(%rip),%xmm6
movaps %xmm6,%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,0x10(%rsp)
lea    0x1(%rsi),%ebx
mov    %ebx,%ecx
test   %esi,%esi
jle    1319 <itrpl2+0x199>
lea    -0x1(%rcx),%r8
mov    $0x1,%eax
cmp    $0x8,%r8
jb     1300 <itrpl2+0x180>
mov    %r8,%rax
and    $0xfffffffffffffff8,%rax
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%rax),%rdx
mov    %rdx,%r9
shr    $0x3,%r9
add    $0x1,%r9
test   %rdx,%rdx
je     1d57 <itrpl2+0xbd7>
mov    %r9,%rdi
and    $0xfffffffffffffffe,%rdi
mov    $0xc,%edx
nopw   0x0(%rax,%rax,1)
movups -0x30(%rbp,%rdx,4),%xmm2
movups -0x20(%rbp,%rdx,4),%xmm3
movups -0x10(%rbp,%rdx,4),%xmm4
movups 0x0(%rbp,%rdx,4),%xmm5
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,-0x30(%rbp,%rdx,4)
movups %xmm3,-0x20(%rbp,%rdx,4)
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm5
movups %xmm4,-0x10(%rbp,%rdx,4)
movups %xmm5,0x0(%rbp,%rdx,4)
add    $0x10,%rdx
add    $0xfffffffffffffffe,%rdi
jne    1290 <itrpl2+0x110>
add    $0xfffffffffffffff5,%rdx
test   $0x1,%r9b
je     12f2 <itrpl2+0x172>
movups -0x4(%rbp,%rdx,4),%xmm2
movups 0xc(%rbp,%rdx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,-0x4(%rbp,%rdx,4)
movups %xmm3,0xc(%rbp,%rdx,4)
cmp    %rax,%r8
je     1319 <itrpl2+0x199>
or     $0x1,%rax
nopl   0x0(%rax,%rax,1)
movss  -0x4(%rbp,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,-0x4(%rbp,%rax,4)
add    $0x1,%rax
cmp    %rax,%rcx
jne    1300 <itrpl2+0x180>
mov    %r14,0x30(%rsp)
xorps  %xmm0,%xmm0
cvtsi2ss %esi,%xmm0
divss  %xmm0,%xmm6
movss  %xmm6,0x2c(%rsp)
mov    %ebx,0x5c(%rsp)
mov    %r15,0x8(%rsp)
mov    0x8(%rsp),%rax
add    %eax,%eax
mov    %eax,0x40(%rsp)
mov    0x8(%rsp),%rax
mov    %rbp,0x38(%rsp)
lea    -0x1(%rax,%rax,1),%ebx
mov    0x8(%rsp),%rax
lea    0x1(%rax),%ebp
mov    $0x1,%edi
mov    0x8(%rsp),%rsi
mov    %rcx,0x20(%rsp)
call   1070 <fvector@plt>
mov    %rax,%r12
mov    $0x1,%edi
mov    %ebx,%esi
mov    0x38(%rsp),%r15
call   1070 <fvector@plt>
mov    %rax,%r13
mov    $0x1,%edi
mov    0x8(%rsp),%rsi
call   1070 <fvector@plt>
mov    %rax,%rbx
mov    $0x1,%edi
mov    0x8(%rsp),%rsi
call   1070 <fvector@plt>
mov    %rax,0xf0(%rsp)
mov    $0x1,%edi
mov    %ebp,%esi
mov    $0x1,%edx
mov    0x8(%rsp),%rcx
call   1080 <fmatrix@plt>
movaps 0xc36(%rip),%xmm6
mov    %rbx,%r10
mov    %rbx,0x70(%rsp)
mov    0x18(%rsp),%r8
mov    0x20(%rsp),%r9
mov    %rax,%r14
mov    0x40(%rsp),%eax
cmp    $0x3,%eax
mov    $0x2,%edx
cmovge %eax,%edx
mov    0x8(%rsp),%r11
lea    -0x2(%rdx),%eax
lea    0x4(,%rax,4),%rax
mov    %rax,0xa8(%rsp)
mov    %r11d,%eax
shl    $0x2,%rax
mov    %rax,0xe0(%rsp)
lea    -0x1(%r9),%rbx
lea    -0x1(%rdx),%rax
add    $0xfffffffffffffffe,%rdx
mov    %rdx,0x100(%rsp)
lea    -0x1(%rbp),%rdx
lea    -0x2(%rbp),%rsi
mov    %rsi,0x40(%rsp)
mov    %eax,%ecx
and    $0x3,%ecx
mov    %rcx,0xd8(%rsp)
and    $0xfffffffffffffffc,%rax
mov    %rax,0x108(%rsp)
mov    %edx,%eax
and    $0x3,%eax
mov    %rax,0x78(%rsp)
mov    %rdx,%rax
and    $0xfffffffffffffffc,%rax
mov    %rax,0xf8(%rsp)
mov    %esi,%eax
and    $0x3,%eax
mov    %rax,0xb8(%rsp)
mov    %rbx,%rdi
and    $0xfffffffffffffffe,%rdi
neg    %rdi
mov    %rdx,%rax
mov    %rdx,0x118(%rsp)
and    $0xfffffffffffffffe,%rdx
neg    %rdx
mov    %rdx,0xd0(%rsp)
and    $0xfffffffffffffffc,%rsi
neg    %rsi
mov    %rsi,0xb0(%rsp)
movss  0xb63(%rip),%xmm9
xorps  %xmm4,%xmm4
movslq %ebp,%rax
mov    %rax,0xc8(%rsp)
lea    0x4(%r13),%rax
mov    %rax,0xa0(%rsp)
lea    0x4(%r10),%rax
mov    %rax,0xc0(%rsp)
mov    %rbp,0x88(%rsp)
lea    -0x3(%rbp),%rax
mov    %rax,0x110(%rsp)
xor    %ebp,%ebp
mov    %rdi,0x80(%rsp)
cmp    $0x64,%ebp
mov    $0x63,%esi
cmovge %ebp,%esi
jmp    1594 <itrpl2+0x414>
cs nopw 0x0(%rax,%rax,1)
nop
mov    %ebp,0x14(%rsp)
mov    %esi,%ebp
movss  %xmm9,0x90(%rsp)
call   1090 <sqrt@plt>
movss  0x90(%rsp),%xmm9
mov    %ebp,%esi
mov    0x14(%rsp),%ebp
xorps  %xmm4,%xmm4
mov    0x80(%rsp),%rdi
mov    0x8(%rsp),%r11
movaps 0xab4(%rip),%xmm6
mov    0x18(%rsp),%r8
mov    0x20(%rsp),%r9
add    $0x1,%ebp
movss  0x4(%rsp),%xmm3
cmpeqss %xmm4,%xmm3
movaps %xmm3,%xmm1
movss  0xaa9(%rip),%xmm2
andps  %xmm2,%xmm1
andnps %xmm0,%xmm3
orps   %xmm1,%xmm3
movaps %xmm9,%xmm0
subss  %xmm3,%xmm0
divss  %xmm9,%xmm0
ucomiss 0x64(%rsp),%xmm0
movaps %xmm3,%xmm9
jbe    16a0 <itrpl2+0x520>
cmp    %esi,%ebp
je     1bc8 <itrpl2+0xa48>
movl   $0x0,0x4(%rsp)
test   %r8d,%r8d
jle    1600 <itrpl2+0x480>
movaps %xmm9,%xmm1
mulss  0x60(%rsp),%xmm1
cmpl   $0x2,0x5c(%rsp)
jne    1630 <itrpl2+0x4b0>
xorps  %xmm0,%xmm0
mov    $0x1,%eax
mov    $0x1,%ecx
test   $0x1,%bl
je     1608 <itrpl2+0x488>
movss  -0x4(%r15,%rcx,4),%xmm2
movaps %xmm2,%xmm3
andps  %xmm6,%xmm3
ucomiss %xmm1,%xmm3
ja     1608 <itrpl2+0x488>
add    $0x1,%eax
mulss  %xmm2,%xmm2
addss  %xmm2,%xmm0
movss  %xmm0,0x4(%rsp)
jmp    1608 <itrpl2+0x488>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    $0x1,%eax
xorps  %xmm0,%xmm0
xorps  %xmm1,%xmm1
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
ucomiss %xmm4,%xmm0
jb     1510 <itrpl2+0x390>
sqrtss %xmm0,%xmm0
jmp    1556 <itrpl2+0x3d6>
cs nopw 0x0(%rax,%rax,1)
nop
xorps  %xmm0,%xmm0
mov    $0x1,%eax
mov    $0x1,%ecx
jmp    1656 <itrpl2+0x4d6>
nop
lea    (%rdi,%rcx,1),%rdx
add    $0x2,%rdx
add    $0x2,%rcx
cmp    $0x1,%rdx
je     15c7 <itrpl2+0x447>
movss  -0x4(%r15,%rcx,4),%xmm2
movaps %xmm2,%xmm3
andps  %xmm6,%xmm3
ucomiss %xmm1,%xmm3
ja     1679 <itrpl2+0x4f9>
add    $0x1,%eax
mulss  %xmm2,%xmm2
addss  %xmm2,%xmm0
movss  %xmm0,0x4(%rsp)
movss  (%r15,%rcx,4),%xmm2
movaps %xmm2,%xmm3
andps  %xmm6,%xmm3
ucomiss %xmm1,%xmm3
ja     1640 <itrpl2+0x4c0>
add    $0x1,%eax
mulss  %xmm2,%xmm2
addss  %xmm2,%xmm0
movss  %xmm0,0x4(%rsp)
jmp    1640 <itrpl2+0x4c0>
nopl   (%rax)
movaps %xmm3,0x90(%rsp)
mov    %rbx,0x68(%rsp)
test   %r11d,%r11d
jle    16c9 <itrpl2+0x549>
mov    0xa0(%rsp),%rdi
xor    %esi,%esi
mov    0xa8(%rsp),%rdx
call   1050 <memset@plt>
mov    0xc0(%rsp),%rdi
xor    %esi,%esi
mov    0xe0(%rsp),%rdx
call   1050 <memset@plt>
cmpl   $0x0,0x18(%rsp)
mov    0x20(%rsp),%r11
mov    0x48(%rsp),%rdi
mov    0xe8(%rsp),%r8
mov    0x70(%rsp),%r10
movaps 0x8fd(%rip),%xmm5
movss  0x904(%rip),%xmm8
mov    0x8(%rsp),%rbx
movss  0x2c(%rsp),%xmm7
mov    0xd8(%rsp),%rsi
xorps  %xmm6,%xmm6
movaps 0x90(%rsp),%xmm0
jle    1910 <itrpl2+0x790>
mulss  0x54(%rsp),%xmm0
mov    $0x1,%eax
jmp    174d <itrpl2+0x5cd>
nopl   (%rax)
add    $0x1,%rax
cmp    %r11,%rax
je     1910 <itrpl2+0x790>
movss  -0x4(%r15,%rax,4),%xmm1
test   %rdi,%rdi
jne    1764 <itrpl2+0x5e4>
movaps %xmm1,%xmm2
andps  %xmm5,%xmm2
ucomiss %xmm0,%xmm2
ja     1740 <itrpl2+0x5c0>
test   %rdi,%rdi
je     1776 <itrpl2+0x5f6>
movss  (%r8,%rax,4),%xmm2
ucomiss %xmm6,%xmm2
jne    1776 <itrpl2+0x5f6>
jnp    1740 <itrpl2+0x5c0>
xorps  %xmm2,%xmm2
cvtsi2ss %eax,%xmm2
mulss  %xmm7,%xmm2
test   %ebx,%ebx
mov    0x108(%rsp),%rdx
jle    183d <itrpl2+0x6bd>
mov    $0x1,%ecx
movaps %xmm8,%xmm3
cmpq   $0x3,0x100(%rsp)
jb     1811 <itrpl2+0x691>
movaps %xmm8,%xmm3
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movaps %xmm2,%xmm4
mulss  %xmm3,%xmm4
addss  0x4(%r13,%rcx,4),%xmm3
movss  %xmm3,0x4(%r13,%rcx,4)
movaps %xmm2,%xmm3
mulss  %xmm4,%xmm3
addss  0x8(%r13,%rcx,4),%xmm4
movss  %xmm4,0x8(%r13,%rcx,4)
movaps %xmm2,%xmm4
mulss  %xmm3,%xmm4
addss  0xc(%r13,%rcx,4),%xmm3
movss  %xmm3,0xc(%r13,%rcx,4)
movaps %xmm2,%xmm3
mulss  %xmm4,%xmm3
addss  0x10(%r13,%rcx,4),%xmm4
movss  %xmm4,0x10(%r13,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    17b0 <itrpl2+0x630>
add    $0x1,%rcx
lea    0x0(,%rcx,4),%rcx
add    %r13,%rcx
xor    %edx,%edx
xchg   %ax,%ax
movaps %xmm2,%xmm4
mulss  %xmm3,%xmm4
addss  (%rcx,%rdx,4),%xmm3
movss  %xmm3,(%rcx,%rdx,4)
add    $0x1,%rdx
movaps %xmm4,%xmm3
cmp    %rdx,%rsi
jne    1820 <itrpl2+0x6a0>
mov    $0x1,%ecx
cmpq   $0x3,0x40(%rsp)
jb     18c1 <itrpl2+0x741>
xor    %ecx,%ecx
mov    0xf8(%rsp),%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movaps %xmm2,%xmm3
mulss  %xmm1,%xmm3
addss  0x4(%r10,%rcx,4),%xmm1
movss  %xmm1,0x4(%r10,%rcx,4)
movaps %xmm2,%xmm1
mulss  %xmm3,%xmm1
addss  0x8(%r10,%rcx,4),%xmm3
movss  %xmm3,0x8(%r10,%rcx,4)
movaps %xmm2,%xmm3
mulss  %xmm1,%xmm3
addss  0xc(%r10,%rcx,4),%xmm1
movss  %xmm1,0xc(%r10,%rcx,4)
movaps %xmm2,%xmm1
mulss  %xmm3,%xmm1
addss  0x10(%r10,%rcx,4),%xmm3
movss  %xmm3,0x10(%r10,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rdx
jne    1860 <itrpl2+0x6e0>
add    $0x1,%rcx
mov    0x78(%rsp),%r9
test   %r9,%r9
je     1740 <itrpl2+0x5c0>
lea    (%r10,%rcx,4),%rcx
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movaps %xmm2,%xmm3
mulss  %xmm1,%xmm3
addss  (%rcx,%rdx,4),%xmm1
movss  %xmm1,(%rcx,%rdx,4)
add    $0x1,%rdx
movaps %xmm3,%xmm1
cmp    %rdx,%r9
jne    18e0 <itrpl2+0x760>
jmp    1740 <itrpl2+0x5c0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ebp,0x14(%rsp)
mov    0xc8(%rsp),%rax
mov    (%r14,%rax,8),%r8
mov    $0x1,%ecx
movabs $0x200000000,%rbx
mov    %rbx,%r9
movabs $0x100000000,%r15
mov    %r15,%r11
mov    0xd0(%rsp),%rbp
jmp    1974 <itrpl2+0x7f4>
nopl   0x0(%rax)
movss  (%r10,%rcx,4),%xmm0
movss  %xmm0,(%r8,%rcx,4)
add    $0x1,%rcx
add    %r15,%r11
add    %r15,%r9
cmp    0x88(%rsp),%rcx
je     1a10 <itrpl2+0x890>
mov    $0x1,%edi
cmpq   $0x0,0x40(%rsp)
je     19d7 <itrpl2+0x857>
mov    $0x1,%edi
mov    %r9,%rdx
mov    %r11,%rax
nopl   0x0(%rax)
mov    %rax,%rsi
sar    $0x1e,%rsi
movss  0x0(%r13,%rsi,1),%xmm0
mov    (%r14,%rdi,8),%rsi
movss  %xmm0,(%rsi,%rcx,4)
mov    %rdx,%rsi
sar    $0x1e,%rsi
movss  0x0(%r13,%rsi,1),%xmm0
mov    0x8(%r14,%rdi,8),%rsi
movss  %xmm0,(%rsi,%rcx,4)
add    %rbx,%rax
add    %rbx,%rdx
lea    (%rdi,%rbp,1),%rsi
add    $0x2,%rsi
add    $0x2,%rdi
cmp    $0x1,%rsi
jne    1990 <itrpl2+0x810>
testb  $0x1,0x118(%rsp)
01
je     1950 <itrpl2+0x7d0>
lea    (%r15,%rcx,1),%rax
add    $0xffffffffffffffff,%rax
add    %edi,%eax
cltq
movss  0x0(%r13,%rax,4),%xmm0
mov    (%r14,%rdi,8),%rax
movss  %xmm0,(%rax,%rcx,4)
jmp    1950 <itrpl2+0x7d0>
cs nopw 0x0(%rax,%rax,1)
mov    %r14,%rdi
mov    %r12,%rsi
mov    0x8(%rsp),%rdx
mov    0x30(%rsp),%rbp
mov    %rbp,%rcx
lea    0x124(%rsp),%r8
call   1030 <gauss@plt>
mov    0x0(%rbp),%eax
cmp    $0x1,%eax
jne    1d7e <itrpl2+0xbfe>
mov    0x18(%rsp),%r8
test   %r8d,%r8d
mov    0x20(%rsp),%r9
movss  0x5be(%rip),%xmm8
mov    0x68(%rsp),%rbx
movss  0x2c(%rsp),%xmm7
jle    1d9c <itrpl2+0xc1c>
movaps 0x90(%rsp),%xmm9
movaps %xmm9,%xmm0
mulss  0x58(%rsp),%xmm0
mov    $0x1,%eax
mov    $0x1,%ecx
mov    0x38(%rsp),%r15
movaps 0x574(%rip),%xmm6
mov    0x8(%rsp),%r11
mov    0xb8(%rsp),%rdi
mov    0xb0(%rsp),%rbp
jmp    1add <itrpl2+0x95d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movss  -0x4(%r15,%rcx,4),%xmm2
subss  %xmm1,%xmm2
andps  %xmm6,%xmm1
ucomiss %xmm0,%xmm1
mov    $0x0,%edx
cmova  %edx,%eax
movss  %xmm2,-0x4(%r15,%rcx,4)
add    $0x1,%rcx
cmp    %r9,%rcx
je     1baf <itrpl2+0xa2f>
movss  0x4(%r12),%xmm1
cmp    $0x2,%r11d
jl     1ab0 <itrpl2+0x930>
xorps  %xmm2,%xmm2
cvtsi2ss %ecx,%xmm2
mulss  %xmm7,%xmm2
mov    $0x2,%edx
cmpq   $0x3,0x110(%rsp)
jae    1b10 <itrpl2+0x990>
movaps %xmm8,%xmm3
jmp    1b7a <itrpl2+0x9fa>
nopl   0x0(%rax,%rax,1)
mov    $0x2,%edx
movaps %xmm8,%xmm3
nopl   0x0(%rax)
mulss  %xmm2,%xmm3
movaps %xmm2,%xmm4
mulss  %xmm3,%xmm4
mulss  (%r12,%rdx,4),%xmm3
addss  %xmm1,%xmm3
movaps %xmm2,%xmm5
mulss  %xmm4,%xmm5
mulss  0x4(%r12,%rdx,4),%xmm4
addss  %xmm3,%xmm4
movaps %xmm2,%xmm3
mulss  %xmm5,%xmm3
mulss  0x8(%r12,%rdx,4),%xmm5
addss  %xmm4,%xmm5
movss  0xc(%r12,%rdx,4),%xmm1
mulss  %xmm3,%xmm1
addss  %xmm5,%xmm1
lea    (%rdx,%rbp,1),%rsi
add    $0x4,%rsi
add    $0x4,%rdx
cmp    $0x2,%rsi
jne    1b20 <itrpl2+0x9a0>
test   %rdi,%rdi
je     1ab0 <itrpl2+0x930>
lea    (%r12,%rdx,4),%rdx
xor    %esi,%esi
nopl   0x0(%rax)
mulss  %xmm2,%xmm3
movss  (%rdx,%rsi,4),%xmm4
mulss  %xmm3,%xmm4
addss  %xmm4,%xmm1
add    $0x1,%rsi
cmp    %rsi,%rdi
jne    1b90 <itrpl2+0xa10>
jmp    1ab0 <itrpl2+0x930>
test   %eax,%eax
mov    0x80(%rsp),%rdi
xorps  %xmm4,%xmm4
mov    0x14(%rsp),%ebp
je     14f5 <itrpl2+0x375>
jmp    1be5 <itrpl2+0xa65>
mov    0x30(%rsp),%rcx
mov    (%rcx),%eax
cmpq   $0x0,0x48(%rsp)
je     1bde <itrpl2+0xa5e>
add    $0x7d0,%eax
jmp    1be3 <itrpl2+0xa63>
add    $0x3e8,%eax
mov    %eax,(%rcx)
movss  0x423(%rip),%xmm0
divss  0x10(%rsp),%xmm0
movss  %xmm0,0x10(%rsp)
test   %r8d,%r8d
jle    1ceb <itrpl2+0xb6b>
mov    $0x1,%eax
cmp    $0x8,%rbx
jb     1cd0 <itrpl2+0xb50>
mov    %rbx,%rax
and    $0xfffffffffffffff8,%rax
movaps %xmm0,%xmm1
shufps $0x0,%xmm0,%xmm1
lea    -0x8(%rax),%rcx
mov    %rcx,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rcx,%rcx
je     1d6b <itrpl2+0xbeb>
mov    %rdx,%rsi
and    $0xfffffffffffffffe,%rsi
mov    $0xc,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movups -0x30(%r15,%rcx,4),%xmm2
movups -0x20(%r15,%rcx,4),%xmm3
movups -0x10(%r15,%rcx,4),%xmm4
movups (%r15,%rcx,4),%xmm5
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,-0x30(%r15,%rcx,4)
movups %xmm3,-0x20(%r15,%rcx,4)
mulps  %xmm1,%xmm4
mulps  %xmm1,%xmm5
movups %xmm4,-0x10(%r15,%rcx,4)
movups %xmm5,(%r15,%rcx,4)
add    $0x10,%rcx
add    $0xfffffffffffffffe,%rsi
jne    1c50 <itrpl2+0xad0>
add    $0xfffffffffffffff5,%rcx
test   $0x1,%dl
je     1cbb <itrpl2+0xb3b>
movups -0x4(%r15,%rcx,4),%xmm2
movups 0xc(%r15,%rcx,4),%xmm3
mulps  %xmm1,%xmm2
mulps  %xmm1,%xmm3
movups %xmm2,-0x4(%r15,%rcx,4)
movups %xmm3,0xc(%r15,%rcx,4)
cmp    %rax,%rbx
je     1ceb <itrpl2+0xb6b>
or     $0x1,%rax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  -0x4(%r15,%rax,4),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,-0x4(%r15,%rax,4)
add    $0x1,%rax
cmp    %rax,%r9
jne    1cd0 <itrpl2+0xb50>
mov    %r12,%rdi
mov    $0x1,%esi
call   1040 <free_fvector@plt>
mov    %r13,%rdi
mov    $0x1,%esi
call   1040 <free_fvector@plt>
mov    0x70(%rsp),%rdi
mov    $0x1,%esi
call   1040 <free_fvector@plt>
mov    0xf0(%rsp),%rdi
mov    $0x1,%esi
call   1040 <free_fvector@plt>
mov    %r14,%rdi
mov    $0x1,%esi
mov    0x88(%rsp),%rdx
mov    $0x1,%ecx
mov    0x8(%rsp),%r8
call   1060 <free_fmatrix@plt>
add    $0x128,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    $0x1,%edx
test   $0x1,%r9b
jne    12d8 <itrpl2+0x158>
jmp    12f2 <itrpl2+0x172>
mov    $0x1,%ecx
test   $0x1,%dl
jne    1c9d <itrpl2+0xb1d>
jmp    1cbb <itrpl2+0xb3b>
cmpq   $0x0,0x48(%rsp)
mov    0x20(%rsp),%r9
mov    0x18(%rsp),%r8
mov    0x68(%rsp),%rbx
je     1db5 <itrpl2+0xc35>
add    $0x7d0,%eax
jmp    1dba <itrpl2+0xc3a>
movss  0x26c(%rip),%xmm0
divss  0x10(%rsp),%xmm0
movss  %xmm0,0x10(%rsp)
jmp    1ceb <itrpl2+0xb6b>
add    $0x3e8,%eax
mov    0x38(%rsp),%r15
mov    0x30(%rsp),%rcx
jmp    1be3 <itrpl2+0xa63>

LLVM IR (-O0):
define void @itrpl2(float* %0, float* %1, i32 %2, i32 %3, float %4, float %5, float %6, float %7, i32* %8) {
%10 = alloca float*
%11 = alloca float*
%12 = alloca i32
%13 = alloca i32
%14 = alloca float
%15 = alloca float
%16 = alloca float
%17 = alloca float
%18 = alloca i32*
%19 = alloca float
%20 = alloca float
%21 = alloca float
%22 = alloca float
%23 = alloca float
%24 = alloca float
%25 = alloca float
%26 = alloca float
%27 = alloca float
%28 = alloca float
%29 = alloca float
%30 = alloca float
%31 = alloca float
%32 = alloca float
%33 = alloca float
%34 = alloca float
%35 = alloca float*
%36 = alloca float*
%37 = alloca float*
%38 = alloca float*
%39 = alloca float**
%40 = alloca float
%41 = alloca i32
%42 = alloca i32
%43 = alloca i32
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
%47 = alloca i32
%48 = alloca i32
%49 = alloca i32
%50 = alloca i32
store float* %0, float** %10
store float* %1, float** %11
store i32 %2, i32* %12
store i32 %3, i32* %13
store float %4, float* %14
store float %5, float* %15
store float %6, float* %16
store float %7, float* %17
store i32* %8, i32** %18
store float 1.000000e+02, float* %19
store float 0x3F847AE140000000, float* %20
store i32 100, i32* %49
store i32 0, i32* %50
%51 = load i32, i32* %13
%52 = icmp sle i32 %51, 0
br i1 %52, label %53, label %54
53: ; preds = %9
br label %455
54: ; preds = %9
%55 = load float*, float** %10
%56 = getelementptr inbounds float, float* %55, i32 -1
store float* %56, float** %10
%57 = load float*, float** %11
%58 = icmp ne float* %57, null
br i1 %58, label %59, label %62
59: ; preds = %54
%60 = load float*, float** %11
%61 = getelementptr inbounds float, float* %60, i32 -1
store float* %61, float** %11
br label %62
62: ; preds = %59, %54
%63 = load float*, float** %10
%64 = getelementptr inbounds float, float* %63, i64 1
%65 = load i32, i32* %12
%66 = call i32 @minmax(float* %64, i32 %65, float* %22, float* %21)
%67 = load float, float* %22
%68 = call float @fabs(float %67)
store float %68, float* %22
%69 = load float, float* %21
%70 = call float @fabs(float %69)
store float %70, float* %21
%71 = load float, float* %22
%72 = load float, float* %21
%73 = fcmp ogt float %71, %72
br i1 %73, label %74, label %76
74: ; preds = %62
%75 = load float, float* %22
store float %75, float* %21
br label %76
76: ; preds = %74, %62
%77 = load float, float* %21
%78 = fcmp oeq float %77, 0.000000e+00
br i1 %78, label %79, label %80
79: ; preds = %76
br label %455
80: ; preds = %76
%81 = load float, float* %21
%82 = fpext float %81 to double
%83 = fdiv double 1.000000e+00, %82
%84 = fptrunc double %83 to float
store float %84, float* %21
store i32 1, i32* %42
br label %85
85: ; preds = %97, %80
%86 = load i32, i32* %42
%87 = load i32, i32* %12
%88 = icmp sle i32 %86, %87
br i1 %88, label %89, label %100
89: ; preds = %85
%90 = load float, float* %21
%91 = load float*, float** %10
%92 = load i32, i32* %42
%93 = sext i32 %92 to i64
%94 = getelementptr inbounds float, float* %91, i64 %93
%95 = load float, float* %94
%96 = fmul float %95, %90
store float %96, float* %94
br label %97
97: ; preds = %89
%98 = load i32, i32* %42
%99 = add nsw i32 %98, 1
store i32 %99, i32* %42
br label %85
100: ; preds = %85
%101 = load i32, i32* %12
%102 = sitofp i32 %101 to float
%103 = fpext float %102 to double
%104 = fdiv double 1.000000e+00, %103
%105 = fptrunc double %104 to float
store float %105, float* %23
%106 = load i32, i32* %13
%107 = mul nsw i32 2, %106
%108 = sub nsw i32 %107, 1
store i32 %108, i32* %45
%109 = load i32, i32* %13
%110 = add nsw i32 %109, 1
store i32 %110, i32* %46
%111 = load i32, i32* %13
%112 = call float* @fvector(i32 1, i32 %111)
store float* %112, float** %35
%113 = load i32, i32* %45
%114 = call float* @fvector(i32 1, i32 %113)
store float* %114, float** %36
%115 = load i32, i32* %13
%116 = call float* @fvector(i32 1, i32 %115)
store float* %116, float** %37
%117 = load i32, i32* %13
%118 = call float* @fvector(i32 1, i32 %117)
store float* %118, float** %38
%119 = load i32, i32* %46
%120 = load i32, i32* %13
%121 = call float** @fmatrix(i32 1, i32 %119, i32 1, i32 %120)
store float** %121, float*** %39
store i32 0, i32* %47
%122 = load float, float* %19
store float %122, float* %25
br label %123
123: ; preds = %421, %193, %100
%124 = load i32, i32* %50
%125 = icmp ne i32 %124, 0
%126 = xor i1 %125, true
br i1 %126, label %127, label %422
127: ; preds = %123
%128 = load i32, i32* %47
%129 = add nsw i32 %128, 1
store i32 %129, i32* %47
%130 = load i32, i32* %47
%131 = load i32, i32* %49
%132 = icmp sge i32 %130, %131
br i1 %132, label %133, label %145
133: ; preds = %127
%134 = load float*, float** %11
%135 = icmp ne float* %134, null
br i1 %135, label %136, label %140
136: ; preds = %133
%137 = load i32*, i32** %18
%138 = load i32, i32* %137
%139 = add nsw i32 %138, 2000
store i32 %139, i32* %137
br label %144
140: ; preds = %133
%141 = load i32*, i32** %18
%142 = load i32, i32* %141
%143 = add nsw i32 %142, 1000
store i32 %143, i32* %141
br label %144
144: ; preds = %140, %136
br label %422
145: ; preds = %127
%146 = load float, float* %25
store float %146, float* %24
store i32 1, i32* %48
store float 0.000000e+00, float* %22
store i32 1, i32* %42
br label %147
147: ; preds = %171, %145
%148 = load i32, i32* %42
%149 = load i32, i32* %12
%150 = icmp sle i32 %148, %149
br i1 %150, label %151, label %174
151: ; preds = %147
%152 = load float*, float** %10
%153 = load i32, i32* %42
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds float, float* %152, i64 %154
%156 = load float, float* %155
%157 = call float @fabs(float %156)
store float %157, float* %26
%158 = load float, float* %14
%159 = load float, float* %24
%160 = fmul float %158, %159
%161 = load float, float* %26
%162 = fcmp olt float %160, %161
br i1 %162, label %163, label %164
163: ; preds = %151
br label %171
164: ; preds = %151
%165 = load i32, i32* %48
%166 = add nsw i32 %165, 1
store i32 %166, i32* %48
%167 = load float, float* %26
%168 = load float, float* %26
%169 = load float, float* %22
%170 = call float @llvm.fmuladd.f32(float %167, float %168, float %169)
store float %170, float* %22
br label %171
171: ; preds = %164, %163
%172 = load i32, i32* %42
%173 = add nsw i32 %172, 1
store i32 %173, i32* %42
br label %147
174: ; preds = %147
%175 = load float, float* %22
%176 = load i32, i32* %48
%177 = sitofp i32 %176 to float
%178 = fdiv float %175, %177
%179 = call float @sqrt(float %178)
store float %179, float* %25
%180 = load float, float* %22
%181 = fpext float %180 to double
%182 = fcmp oeq double %181, 0.000000e+00
br i1 %182, label %183, label %185
183: ; preds = %174
%184 = load float, float* %20
store float %184, float* %25
br label %185
185: ; preds = %183, %174
%186 = load float, float* %24
%187 = load float, float* %25
%188 = fsub float %186, %187
%189 = load float, float* %24
%190 = fdiv float %188, %189
%191 = load float, float* %16
%192 = fcmp ogt float %190, %191
br i1 %192, label %193, label %194
193: ; preds = %185
br label %123
194: ; preds = %185
%195 = load float, float* %15
%196 = load float, float* %25
%197 = fmul float %195, %196
store float %197, float* %27
store i32 1, i32* %44
br label %198
198: ; preds = %207, %194
%199 = load i32, i32* %44
%200 = load i32, i32* %45
%201 = icmp sle i32 %199, %200
br i1 %201, label %202, label %210
202: ; preds = %198
%203 = load float*, float** %36
%204 = load i32, i32* %44
%205 = sext i32 %204 to i64
%206 = getelementptr inbounds float, float* %203, i64 %205
store float 0.000000e+00, float* %206
br label %207
207: ; preds = %202
%208 = load i32, i32* %44
%209 = add nsw i32 %208, 1
store i32 %209, i32* %44
br label %198
210: ; preds = %198
store i32 1, i32* %42
br label %211
211: ; preds = %220, %210
%212 = load i32, i32* %42
%213 = load i32, i32* %13
%214 = icmp sle i32 %212, %213
br i1 %214, label %215, label %223
215: ; preds = %211
%216 = load float*, float** %37
%217 = load i32, i32* %42
%218 = sext i32 %217 to i64
%219 = getelementptr inbounds float, float* %216, i64 %218
store float 0.000000e+00, float* %219
br label %220
220: ; preds = %215
%221 = load i32, i32* %42
%222 = add nsw i32 %221, 1
store i32 %222, i32* %42
br label %211
223: ; preds = %211
store i32 1, i32* %41
br label %224
224: ; preds = %298, %223
%225 = load i32, i32* %41
%226 = load i32, i32* %12
%227 = icmp sle i32 %225, %226
br i1 %227, label %228, label %301
228: ; preds = %224
%229 = load float*, float** %10
%230 = load i32, i32* %41
%231 = sext i32 %230 to i64
%232 = getelementptr inbounds float, float* %229, i64 %231
%233 = load float, float* %232
store float %233, float* %29
%234 = load float*, float** %11
%235 = icmp ne float* %234, null
br i1 %235, label %242, label %236
236: ; preds = %228
%237 = load float, float* %29
%238 = call float @fabs(float %237)
%239 = load float, float* %27
%240 = fcmp ogt float %238, %239
br i1 %240, label %241, label %242
241: ; preds = %236
br label %298
242: ; preds = %236, %228
%243 = load float*, float** %11
%244 = icmp ne float* %243, null
br i1 %244, label %245, label %254
245: ; preds = %242
%246 = load float*, float** %11
%247 = load i32, i32* %41
%248 = sext i32 %247 to i64
%249 = getelementptr inbounds float, float* %246, i64 %248
%250 = load float, float* %249
%251 = fpext float %250 to double
%252 = fcmp oeq double %251, 0.000000e+00
br i1 %252, label %253, label %254
253: ; preds = %245
br label %298
254: ; preds = %245, %242
%255 = load i32, i32* %41
%256 = sitofp i32 %255 to float
%257 = load float, float* %23
%258 = fmul float %256, %257
store float %258, float* %28
store float 1.000000e+00, float* %30
store i32 1, i32* %44
br label %259
259: ; preds = %274, %254
%260 = load i32, i32* %44
%261 = load i32, i32* %45
%262 = icmp sle i32 %260, %261
br i1 %262, label %263, label %277
263: ; preds = %259
%264 = load float, float* %30
%265 = load float*, float** %36
%266 = load i32, i32* %44
%267 = sext i32 %266 to i64
%268 = getelementptr inbounds float, float* %265, i64 %267
%269 = load float, float* %268
%270 = fadd float %269, %264
store float %270, float* %268
%271 = load float, float* %28
%272 = load float, float* %30
%273 = fmul float %272, %271
store float %273, float* %30
br label %274
274: ; preds = %263
%275 = load i32, i32* %44
%276 = add nsw i32 %275, 1
store i32 %276, i32* %44
br label %259
277: ; preds = %259
%278 = load float, float* %29
store float %278, float* %31
store i32 1, i32* %44
br label %279
279: ; preds = %294, %277
%280 = load i32, i32* %44
%281 = load i32, i32* %13
%282 = icmp sle i32 %280, %281
br i1 %282, label %283, label %297
283: ; preds = %279
%284 = load float, float* %31
%285 = load float*, float** %37
%286 = load i32, i32* %44
%287 = sext i32 %286 to i64
%288 = getelementptr inbounds float, float* %285, i64 %287
%289 = load float, float* %288
%290 = fadd float %289, %284
store float %290, float* %288
%291 = load float, float* %28
%292 = load float, float* %31
%293 = fmul float %292, %291
store float %293, float* %31
br label %294
294: ; preds = %283
%295 = load i32, i32* %44
%296 = add nsw i32 %295, 1
store i32 %296, i32* %44
br label %279
297: ; preds = %279
br label %298
298: ; preds = %297, %253, %241
%299 = load i32, i32* %41
%300 = add nsw i32 %299, 1
store i32 %300, i32* %41
br label %224
301: ; preds = %224
store i32 1, i32* %42
br label %302
302: ; preds = %346, %301
%303 = load i32, i32* %42
%304 = load i32, i32* %13
%305 = icmp sle i32 %303, %304
br i1 %305, label %306, label %349
306: ; preds = %302
store i32 1, i32* %43
br label %307
307: ; preds = %329, %306
%308 = load i32, i32* %43
%309 = load i32, i32* %13
%310 = icmp sle i32 %308, %309
br i1 %310, label %311, label %332
311: ; preds = %307
%312 = load i32, i32* %42
%313 = load i32, i32* %43
%314 = add nsw i32 %312, %313
%315 = sub nsw i32 %314, 1
store i32 %315, i32* %44
%316 = load float*, float** %36
%317 = load i32, i32* %44
%318 = sext i32 %317 to i64
%319 = getelementptr inbounds float, float* %316, i64 %318
%320 = load float, float* %319
%321 = load float**, float*** %39
%322 = load i32, i32* %43
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds float*, float** %321, i64 %323
%325 = load float*, float** %324
%326 = load i32, i32* %42
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds float, float* %325, i64 %327
store float %320, float* %328
br label %329
329: ; preds = %311
%330 = load i32, i32* %43
%331 = add nsw i32 %330, 1
store i32 %331, i32* %43
br label %307
332: ; preds = %307
%333 = load float*, float** %37
%334 = load i32, i32* %42
%335 = sext i32 %334 to i64
%336 = getelementptr inbounds float, float* %333, i64 %335
%337 = load float, float* %336
%338 = load float**, float*** %39
%339 = load i32, i32* %46
%340 = sext i32 %339 to i64
%341 = getelementptr inbounds float*, float** %338, i64 %340
%342 = load float*, float** %341
%343 = load i32, i32* %42
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds float, float* %342, i64 %344
store float %337, float* %345
br label %346
346: ; preds = %332
%347 = load i32, i32* %42
%348 = add nsw i32 %347, 1
store i32 %348, i32* %42
br label %302
349: ; preds = %302
%350 = load float**, float*** %39
%351 = load float*, float** %35
%352 = load i32, i32* %13
%353 = load i32*, i32** %18
%354 = call i32 @gauss(float** %350, float* %351, i32 %352, i32* %353, float* %40)
store i32 1, i32* %50
%355 = load i32*, i32** %18
%356 = load i32, i32* %355
%357 = icmp ne i32 %356, 1
br i1 %357, label %358, label %370
358: ; preds = %349
%359 = load float*, float** %11
%360 = icmp ne float* %359, null
br i1 %360, label %361, label %365
361: ; preds = %358
%362 = load i32*, i32** %18
%363 = load i32, i32* %362
%364 = add nsw i32 %363, 2000
store i32 %364, i32* %362
br label %369
365: ; preds = %358
%366 = load i32*, i32** %18
%367 = load i32, i32* %366
%368 = add nsw i32 %367, 1000
store i32 %368, i32* %366
br label %369
369: ; preds = %365, %361
br label %422
370: ; preds = %349
store i32 1, i32* %42
br label %371
371: ; preds = %418, %370
%372 = load i32, i32* %42
%373 = load i32, i32* %12
%374 = icmp sle i32 %372, %373
br i1 %374, label %375, label %421
375: ; preds = %371
%376 = load float*, float** %35
%377 = getelementptr inbounds float, float* %376, i64 1
%378 = load float, float* %377
store float %378, float* %32
%379 = load i32, i32* %42
%380 = sitofp i32 %379 to float
%381 = load float, float* %23
%382 = fmul float %380, %381
store float %382, float* %33
store float 1.000000e+00, float* %34
store i32 2, i32* %43
br label %383
383: ; preds = %399, %375
%384 = load i32, i32* %43
%385 = load i32, i32* %13
%386 = icmp sle i32 %384, %385
br i1 %386, label %387, label %402
387: ; preds = %383
%388 = load float, float* %33
%389 = load float, float* %34
%390 = fmul float %389, %388
store float %390, float* %34
%391 = load float*, float** %35
%392 = load i32, i32* %43
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds float, float* %391, i64 %393
%395 = load float, float* %394
%396 = load float, float* %34
%397 = load float, float* %32
%398 = call float @llvm.fmuladd.f32(float %395, float %396, float %397)
store float %398, float* %32
br label %399
399: ; preds = %387
%400 = load i32, i32* %43
%401 = add nsw i32 %400, 1
store i32 %401, i32* %43
br label %383
402: ; preds = %383
%403 = load float, float* %32
%404 = load float*, float** %10
%405 = load i32, i32* %42
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds float, float* %404, i64 %406
%408 = load float, float* %407
%409 = fsub float %408, %403
store float %409, float* %407
%410 = load float, float* %32
%411 = call float @fabs(float %410)
%412 = load float, float* %17
%413 = load float, float* %25
%414 = fmul float %412, %413
%415 = fcmp ogt float %411, %414
br i1 %415, label %416, label %417
416: ; preds = %402
store i32 0, i32* %50
br label %417
417: ; preds = %416, %402
br label %418
418: ; preds = %417
%419 = load i32, i32* %42
%420 = add nsw i32 %419, 1
store i32 %420, i32* %42
br label %371
421: ; preds = %371
br label %123
422: ; preds = %369, %144, %123
%423 = load float, float* %21
%424 = fpext float %423 to double
%425 = fdiv double 1.000000e+00, %424
%426 = fptrunc double %425 to float
store float %426, float* %21
store i32 1, i32* %42
br label %427
427: ; preds = %439, %422
%428 = load i32, i32* %42
%429 = load i32, i32* %12
%430 = icmp sle i32 %428, %429
br i1 %430, label %431, label %442
431: ; preds = %427
%432 = load float, float* %21
%433 = load float*, float** %10
%434 = load i32, i32* %42
%435 = sext i32 %434 to i64
%436 = getelementptr inbounds float, float* %433, i64 %435
%437 = load float, float* %436
%438 = fmul float %437, %432
store float %438, float* %436
br label %439
439: ; preds = %431
%440 = load i32, i32* %42
%441 = add nsw i32 %440, 1
store i32 %441, i32* %42
br label %427
442: ; preds = %427
%443 = load float*, float** %35
%444 = call i32 @free_fvector(float* %443, i32 1)
%445 = load float*, float** %36
%446 = call i32 @free_fvector(float* %445, i32 1)
%447 = load float*, float** %37
%448 = call i32 @free_fvector(float* %447, i32 1)
%449 = load float*, float** %38
%450 = call i32 @free_fvector(float* %449, i32 1)
%451 = load float**, float*** %39
%452 = load i32, i32* %46
%453 = load i32, i32* %13
%454 = call i32 @free_fmatrix(float** %451, i32 1, i32 %452, i32 1, i32 %453)
br label %455
455: ; preds = %442, %79, %53
ret void
}

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