#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 */
int /*<<< orphan*/ Scovsrt(double **, int, int *, int);
int Sgaussj(double **, int, double **, int);
double *dblVector(long, long);
double **dmatrix(long, long, long, long);
int /*<<< orphan*/ free_dblVector(double *, long);
int /*<<< orphan*/ free_dmatrix(double **, long, long);
int /*<<< orphan*/ printf(char *);
double sqrt(double);
void stub1(double, double *, int);
int Slfit(double xdat[], double ydat[], double sigma[], int ndat,
          double coeff[], int coeffMask[], int ndim, double **covar,
          void (*funcs)(double, double[], int)) {
  int mfit = 0, status;
  double ym, weight, sig2i, **beta, *basisFunc;
  beta = dmatrix((long)1, (long)ndim, (long)1, (long)1);
  basisFunc = dblVector((long)1, (long)ndim);
  for (int j = 1; j <= ndim; j++)
    if (coeffMask[j])
      mfit++;
  if (mfit == 0) {
    printf("lfit: There are no parameters to be fit.\n");
    return (1);
  }
  for (int j = 1; j <= mfit; j++) {
    for (int k = 1; k <= mfit; k++)
      covar[j][k] = 0.0;
    beta[j][1] = 0.0;
  }
  int j, k, l, m;
  for (int i = 1; i <= ndat; i++) {
    (*funcs)(xdat[i], basisFunc, ndim);
    ym = ydat[i];
    if (mfit < ndim) {
      for (j = 1; j <= ndim; j++)
        if (!coeffMask[j])
          ym -= coeff[j] * basisFunc[j];
    }
    sig2i = 1.0 / sqrt(sigma[i]);
    for (j = 0, l = 1; l <= ndim; l++) {
      if (coeffMask[l]) {
        weight = basisFunc[l] * sig2i;
        for (j++, k = 0, m = 1; m <= l; m++)
          if (coeffMask[m])
            covar[j][++k] += weight * basisFunc[m];
        beta[j][1] += ym * weight;
      }
    }
  }
  for (j = 2; j <= mfit; j++)
    for (k = 1; k < j; k++)
      covar[k][j] = covar[j][k];
  if ((status = Sgaussj(covar, mfit, beta, 1)))
    return (status);
  for (j = 0, l = 1; l <= ndim; l++)
    if (coeffMask[l])
      coeff[l] = beta[++j][1];
  Scovsrt(covar, ndim, coeffMask, mfit);
  free_dblVector(basisFunc, (long)1);
  free_dmatrix(beta, (long)1, (long)1);
  return (0);
}


x86 assembly (clang, -O0):
<Slfit>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%rsp
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8,-0x30(%rbp)
mov    %r9,-0x38(%rbp)
movl   $0x0,-0x3c(%rbp)
movslq 0x10(%rbp),%rsi
mov    $0x1,%ecx
mov    %rcx,%rdi
mov    %rcx,%rdx
call   1060 <dmatrix@plt>
mov    %rax,-0x60(%rbp)
movslq 0x10(%rbp),%rsi
mov    $0x1,%edi
call   1050 <dblVector@plt>
mov    %rax,-0x68(%rbp)
movl   $0x1,-0x6c(%rbp)
mov    -0x6c(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     121f <Slfit+0x9f>
mov    -0x38(%rbp),%rax
movslq -0x6c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     120c <Slfit+0x8c>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1211 <Slfit+0x91>
mov    -0x6c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x6c(%rbp)
jmp    11e5 <Slfit+0x65>
cmpl   $0x0,-0x3c(%rbp)
jne    1241 <Slfit+0xc1>
lea    0xdd8(%rip),%rdi
call   1040 <printf@plt>
movl   $0x1,-0x4(%rbp)
jmp    1617 <Slfit+0x497>
movl   $0x1,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     12af <Slfit+0x12f>
movl   $0x1,-0x74(%rbp)
mov    -0x74(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     128d <Slfit+0x10d>
mov    0x18(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x74(%rbp),%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x74(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x74(%rbp)
jmp    125b <Slfit+0xdb>
mov    -0x60(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
xorps  %xmm0,%xmm0
movsd  %xmm0,0x8(%rax)
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1248 <Slfit+0xc8>
movl   $0x1,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     14dc <Slfit+0x35c>
mov    0x20(%rbp),%rax
mov    -0x10(%rbp),%rcx
movslq -0x88(%rbp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    -0x68(%rbp),%rdi
mov    0x10(%rbp),%esi
call   *%rax
mov    -0x18(%rbp),%rax
movslq -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x48(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x10(%rbp),%eax
jge    1386 <Slfit+0x206>
movl   $0x1,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     1381 <Slfit+0x201>
mov    -0x38(%rbp),%rax
movslq -0x78(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
jne    136e <Slfit+0x1ee>
mov    -0x30(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x78(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x48(%rbp),%xmm1
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x48(%rbp)
jmp    1373 <Slfit+0x1f3>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    130d <Slfit+0x18d>
jmp    1386 <Slfit+0x206>
mov    -0x20(%rbp),%rax
movslq -0x88(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
call   10a0 <sqrt@plt>
movaps %xmm0,%xmm1
movsd  0xc5a(%rip),%xmm0
divsd  %xmm1,%xmm0
movsd  %xmm0,-0x58(%rbp)
movl   $0x0,-0x78(%rbp)
movl   $0x1,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     14c3 <Slfit+0x343>
mov    -0x38(%rbp),%rax
movslq -0x80(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     14b0 <Slfit+0x330>
mov    -0x68(%rbp),%rax
movslq -0x80(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x50(%rbp)
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
movl   $0x0,-0x7c(%rbp)
movl   $0x1,-0x84(%rbp)
mov    -0x84(%rbp),%eax
cmp    -0x80(%rbp),%eax
jg     1488 <Slfit+0x308>
mov    -0x38(%rbp),%rax
movslq -0x84(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     146f <Slfit+0x2ef>
movsd  -0x50(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x84(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x18(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x7c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x7c(%rbp)
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1474 <Slfit+0x2f4>
mov    -0x84(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x84(%rbp)
jmp    140c <Slfit+0x28c>
movsd  -0x48(%rbp),%xmm0
movsd  -0x50(%rbp),%xmm2
mov    -0x60(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,0x8(%rax)
jmp    14b5 <Slfit+0x335>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    13bd <Slfit+0x23d>
jmp    14c8 <Slfit+0x348>
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    12b9 <Slfit+0x139>
movl   $0x2,-0x78(%rbp)
mov    -0x78(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     154d <Slfit+0x3cd>
movl   $0x1,-0x7c(%rbp)
mov    -0x7c(%rbp),%eax
cmp    -0x78(%rbp),%eax
jge    153a <Slfit+0x3ba>
mov    0x18(%rbp),%rax
movslq -0x78(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x7c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x7c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x78(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x7c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x7c(%rbp)
jmp    14f6 <Slfit+0x376>
jmp    153f <Slfit+0x3bf>
mov    -0x78(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x78(%rbp)
jmp    14e3 <Slfit+0x363>
mov    0x18(%rbp),%rdi
mov    -0x3c(%rbp),%esi
mov    -0x60(%rbp),%rdx
mov    $0x1,%ecx
call   1070 <Sgaussj@plt>
mov    %eax,-0x40(%rbp)
cmp    $0x0,%eax
je     1579 <Slfit+0x3f9>
mov    -0x40(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1617 <Slfit+0x497>
movl   $0x0,-0x78(%rbp)
movl   $0x1,-0x80(%rbp)
mov    -0x80(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     15de <Slfit+0x45e>
mov    -0x38(%rbp),%rax
movslq -0x80(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     15cb <Slfit+0x44b>
mov    -0x60(%rbp),%rax
mov    -0x78(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x78(%rbp)
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
mov    -0x30(%rbp),%rax
movslq -0x80(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    15d0 <Slfit+0x450>
mov    -0x80(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x80(%rbp)
jmp    1587 <Slfit+0x407>
mov    0x18(%rbp),%rdi
mov    0x10(%rbp),%esi
mov    -0x38(%rbp),%rdx
mov    -0x3c(%rbp),%ecx
call   1080 <Scovsrt@plt>
mov    -0x68(%rbp),%rdi
mov    $0x1,%esi
call   1030 <free_dblVector@plt>
mov    -0x60(%rbp),%rdi
mov    $0x1,%edx
mov    %rdx,%rsi
call   1090 <free_dmatrix@plt>
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Slfit>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r9,%rbx
mov    %r8,0x40(%rsp)
mov    %rcx,0x28(%rsp)
mov    %rdx,0x60(%rsp)
mov    %rsi,0x58(%rsp)
mov    %rdi,0x50(%rsp)
movslq 0xa0(%rsp),%r14
mov    $0x1,%ebp
mov    $0x1,%edi
mov    $0x1,%edx
mov    $0x1,%ecx
mov    %r14,%rsi
call   1070 <dmatrix@plt>
mov    %rax,(%rsp)
mov    $0x1,%edi
mov    %r14,%rsi
call   1060 <dblVector@plt>
mov    %rax,%r13
mov    %r14,%rax
mov    %r14,0x18(%rsp)
test   %r14,%r14
jle    168a <Slfit+0x4fa>
mov    0x18(%rsp),%rax
mov    %eax,%ecx
mov    %rcx,0x10(%rsp)
lea    0x1(%rcx),%rsi
xor    %ecx,%ecx
cmp    $0x8,%eax
jb     1310 <Slfit+0x180>
mov    0x10(%rsp),%rbp
and    $0xfffffff8,%ebp
lea    -0x8(%rbp),%rcx
mov    %rcx,%rax
shr    $0x3,%rax
add    $0x1,%rax
test   %rcx,%rcx
je     182c <Slfit+0x69c>
mov    %rax,%rdx
and    $0xfffffffffffffffe,%rdx
pxor   %xmm2,%xmm2
xor    %ecx,%ecx
movdqa 0xdad(%rip),%xmm3
pxor   %xmm5,%xmm5
pxor   %xmm4,%xmm4
nopl   0x0(%rax,%rax,1)
movdqu 0x4(%rbx,%rcx,4),%xmm6
movdqu 0x14(%rbx,%rcx,4),%xmm7
movdqu 0x24(%rbx,%rcx,4),%xmm0
movdqu 0x34(%rbx,%rcx,4),%xmm1
pcmpeqd %xmm2,%xmm6
paddd  %xmm5,%xmm6
pcmpeqd %xmm2,%xmm7
paddd  %xmm4,%xmm7
pcmpeqd %xmm2,%xmm0
pcmpeqd %xmm2,%xmm1
paddd  %xmm3,%xmm0
paddd  %xmm6,%xmm0
paddd  %xmm3,%xmm1
paddd  %xmm7,%xmm1
add    $0x10,%rcx
movdqa %xmm0,%xmm5
movdqa %xmm1,%xmm4
add    $0xfffffffffffffffe,%rdx
jne    1260 <Slfit+0xd0>
test   $0x1,%al
je     12e9 <Slfit+0x159>
shl    $0x2,%rcx
or     $0x4,%rcx
movdqu (%rbx,%rcx,1),%xmm2
movdqu 0x10(%rbx,%rcx,1),%xmm3
pxor   %xmm4,%xmm4
pcmpeqd %xmm4,%xmm2
paddd  %xmm2,%xmm0
pcmpeqd %xmm4,%xmm3
paddd  %xmm3,%xmm1
pcmpeqd %xmm2,%xmm2
psubd  %xmm2,%xmm0
psubd  %xmm2,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%ecx
cmp    %rbp,0x10(%rsp)
je     1320 <Slfit+0x190>
or     $0x1,%rbp
xchg   %ax,%ax
cmpl   $0x1,(%rbx,%rbp,4)
sbb    $0xffffffff,%ecx
add    $0x1,%rbp
cmp    %rbp,%rsi
jne    1310 <Slfit+0x180>
test   %ecx,%ecx
je     168a <Slfit+0x4fa>
mov    %rsi,0x38(%rsp)
mov    0xa8(%rsp),%r12
mov    %rcx,0x30(%rsp)
mov    %ecx,%ecx
lea    0x0(,%rcx,8),%r15
lea    -0x1(%rcx),%rax
mov    %rcx,0x8(%rsp)
and    $0x3,%ecx
mov    $0x1,%r14d
cmp    $0x3,%rax
jb     1418 <Slfit+0x288>
mov    %rcx,0x20(%rsp)
mov    0x8(%rsp),%rax
and    $0xfffffffc,%eax
mov    %rax,0x8(%rsp)
xor    %r14d,%r14d
mov    (%rsp),%rbp
nopl   0x0(%rax)
mov    0x8(%r12,%r14,8),%rdi
add    $0x8,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1050 <memset@plt>
mov    0x8(%rbp,%r14,8),%rax
movq   $0x0,0x8(%rax)
mov    0x10(%r12,%r14,8),%rdi
add    $0x8,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1050 <memset@plt>
mov    0x10(%rbp,%r14,8),%rax
movq   $0x0,0x8(%rax)
mov    0x18(%r12,%r14,8),%rdi
add    $0x8,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1050 <memset@plt>
mov    0x18(%rbp,%r14,8),%rax
movq   $0x0,0x8(%rax)
mov    0x20(%r12,%r14,8),%rdi
add    $0x8,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1050 <memset@plt>
mov    0x20(%rbp,%r14,8),%rax
movq   $0x0,0x8(%rax)
add    $0x4,%r14
cmp    %r14,0x8(%rsp)
jne    1380 <Slfit+0x1f0>
add    $0x1,%r14
mov    0x20(%rsp),%rcx
test   %rcx,%rcx
je     1477 <Slfit+0x2e7>
mov    (%rsp),%rax
lea    (%rax,%r14,8),%rax
mov    %rax,0x8(%rsp)
lea    (%r12,%r14,8),%rax
mov    %rax,0x20(%rsp)
xor    %ebp,%ebp
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x20(%rsp),%rax
mov    (%rax,%rbp,8),%rdi
add    $0x8,%rdi
xor    %esi,%esi
mov    %r15,%rdx
mov    %rcx,%r14
call   1050 <memset@plt>
mov    %r14,%rcx
mov    0x8(%rsp),%rax
mov    (%rax,%rbp,8),%rax
movq   $0x0,0x8(%rax)
add    $0x1,%rbp
cmp    %rbp,%r14
jne    1440 <Slfit+0x2b0>
cmpl   $0x0,0x28(%rsp)
jle    16a0 <Slfit+0x510>
mov    0x18(%rsp),%rcx
test   %ecx,%ecx
setle  %al
cmp    %ecx,0x30(%rsp)
setge  %dl
lea    0x1(%rcx),%r15d
mov    0x28(%rsp),%rcx
add    $0x1,%ecx
mov    %rcx,0x28(%rsp)
or     %al,%dl
mov    %dl,0x8(%rsp)
mov    0x10(%rsp),%rax
and    $0xfffffffe,%eax
neg    %rax
mov    %rax,0x48(%rsp)
mov    $0x1,%r14d
jmp    14df <Slfit+0x34f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%r14
cmp    0x28(%rsp),%r14
je     16a0 <Slfit+0x510>
mov    0x50(%rsp),%rax
movsd  (%rax,%r14,8),%xmm0
mov    %r13,%rdi
mov    0x18(%rsp),%rsi
call   *0xb0(%rsp)
mov    0x58(%rsp),%rax
movsd  (%rax,%r14,8),%xmm3
cmpb   $0x0,0x8(%rsp)
jne    1540 <Slfit+0x3b0>
mov    $0x1,%eax
cmpl   $0x2,0x38(%rsp)
mov    0x40(%rsp),%rdx
jne    1620 <Slfit+0x490>
testb  $0x1,0x10(%rsp)
je     1540 <Slfit+0x3b0>
cmpl   $0x0,(%rbx,%rax,4)
jne    1540 <Slfit+0x3b0>
movsd  (%rdx,%rax,8),%xmm0
mulsd  0x0(%r13,%rax,8),%xmm0
subsd  %xmm0,%xmm3
nopl   (%rax)
mov    0x60(%rsp),%rax
movsd  (%rax,%r14,8),%xmm0
ucomisd 0xac5(%rip),%xmm0
jb     1560 <Slfit+0x3d0>
sqrtsd %xmm0,%xmm0
jmp    1571 <Slfit+0x3e1>
nopl   0x0(%rax,%rax,1)
movsd  %xmm3,0x20(%rsp)
call   10b0 <sqrt@plt>
movsd  0x20(%rsp),%xmm3
mov    (%rsp),%r9
cmpl   $0x0,0x18(%rsp)
jle    14d0 <Slfit+0x340>
movsd  0xa88(%rip),%xmm1
divsd  %xmm0,%xmm1
xor    %r8d,%r8d
mov    $0x1,%ecx
jmp    15bf <Slfit+0x42f>
cs nopw 0x0(%rax,%rax,1)
mov    (%r9,%rdx,8),%rax
mulsd  %xmm3,%xmm0
addsd  0x8(%rax),%xmm0
movsd  %xmm0,0x8(%rax)
add    $0x1,%rcx
cmp    %r15,%rcx
je     14d0 <Slfit+0x340>
cmpl   $0x0,(%rbx,%rcx,4)
je     15b2 <Slfit+0x422>
movsd  0x0(%r13,%rcx,8),%xmm0
mulsd  %xmm1,%xmm0
add    $0x1,%r8d
movslq %r8d,%rdx
xor    %esi,%esi
xor    %edi,%edi
jmp    15e9 <Slfit+0x459>
nopl   (%rax)
add    $0x1,%rsi
cmp    %rsi,%rcx
je     15a0 <Slfit+0x410>
cmpl   $0x0,0x4(%rbx,%rsi,4)
je     15e0 <Slfit+0x450>
mov    (%r12,%rdx,8),%rbp
movslq %edi,%rax
add    $0x1,%edi
movsd  0x8(%r13,%rsi,8),%xmm2
mulsd  %xmm0,%xmm2
addsd  0x8(%rbp,%rax,8),%xmm2
movsd  %xmm2,0x8(%rbp,%rax,8)
jmp    15e0 <Slfit+0x450>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    $0x1,%eax
mov    0x48(%rsp),%rsi
jmp    1646 <Slfit+0x4b6>
nopl   0x0(%rax)
lea    (%rsi,%rax,1),%rcx
add    $0x2,%rcx
add    $0x2,%rax
cmp    $0x1,%rcx
je     1520 <Slfit+0x390>
cmpl   $0x0,(%rbx,%rax,4)
je     1660 <Slfit+0x4d0>
cmpl   $0x0,0x4(%rbx,%rax,4)
jne    1630 <Slfit+0x4a0>
jmp    1677 <Slfit+0x4e7>
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%rdx,%rax,8),%xmm0
mulsd  0x0(%r13,%rax,8),%xmm0
subsd  %xmm0,%xmm3
cmpl   $0x0,0x4(%rbx,%rax,4)
jne    1630 <Slfit+0x4a0>
movsd  0x8(%rdx,%rax,8),%xmm0
mulsd  0x8(%r13,%rax,8),%xmm0
subsd  %xmm0,%xmm3
jmp    1630 <Slfit+0x4a0>
lea    0x98f(%rip),%rdi
call   1030 <puts@plt>
mov    $0x1,%eax
jmp    173e <Slfit+0x5ae>
mov    0x30(%rsp),%r14
cmp    $0x2,%r14d
jae    174d <Slfit+0x5bd>
mov    %r12,%rdi
mov    %r14d,%esi
mov    (%rsp),%rdx
mov    $0x1,%ecx
call   1080 <Sgaussj@plt>
test   %eax,%eax
jne    173e <Slfit+0x5ae>
cmpl   $0x0,0x18(%rsp)
mov    0x40(%rsp),%rbp
jle    1709 <Slfit+0x579>
cmpl   $0x2,0x38(%rsp)
jne    1843 <Slfit+0x6b3>
xor    %ecx,%ecx
mov    $0x1,%eax
testb  $0x1,0x10(%rsp)
je     1709 <Slfit+0x579>
cmpl   $0x0,(%rbx,%rax,4)
je     1709 <Slfit+0x579>
movslq %ecx,%rcx
mov    (%rsp),%rdx
mov    0x8(%rdx,%rcx,8),%rcx
movq   0x8(%rcx),%xmm0
movq   %xmm0,0x0(%rbp,%rax,8)
mov    %r12,%rdi
mov    0x18(%rsp),%rsi
mov    %rbx,%rdx
mov    %r14d,%ecx
call   1090 <Scovsrt@plt>
mov    $0x1,%esi
mov    %r13,%rdi
call   1040 <free_dblVector@plt>
mov    $0x1,%esi
mov    $0x1,%edx
mov    (%rsp),%rdi
call   10a0 <free_dmatrix@plt>
xor    %eax,%eax
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
lea    0x1(%r14),%r8d
mov    $0x2,%ecx
mov    $0x1,%r10d
xor    %r9d,%r9d
jmp    1781 <Slfit+0x5f1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x1,%rcx
add    $0x1,%r10
cmp    %r8,%rcx
je     16af <Slfit+0x51f>
mov    %r9,%rdx
add    $0x1,%r9
mov    (%r12,%rcx,8),%rdi
mov    $0x1,%ebp
cmp    $0x3,%rdx
jb     17ed <Slfit+0x65d>
mov    %r10,%rdx
and    $0xfffffffffffffffc,%rdx
xor    %ebp,%ebp
movsd  0x8(%rdi,%rbp,8),%xmm0
mov    0x8(%r12,%rbp,8),%rsi
movsd  %xmm0,(%rsi,%rcx,8)
movsd  0x10(%rdi,%rbp,8),%xmm0
mov    0x10(%r12,%rbp,8),%rsi
movsd  %xmm0,(%rsi,%rcx,8)
movsd  0x18(%rdi,%rbp,8),%xmm0
mov    0x18(%r12,%rbp,8),%rsi
movsd  %xmm0,(%rsi,%rcx,8)
movq   0x20(%rdi,%rbp,8),%xmm0
mov    0x20(%r12,%rbp,8),%rsi
movq   %xmm0,(%rsi,%rcx,8)
add    $0x4,%rbp
cmp    %rbp,%rdx
jne    17a0 <Slfit+0x610>
add    $0x1,%rbp
test   $0x3,%r9b
je     1770 <Slfit+0x5e0>
mov    %r10d,%edx
and    $0x3,%edx
lea    (%r12,%rbp,8),%rsi
lea    (%rdi,%rbp,8),%rdi
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
movq   (%rdi,%rbp,8),%xmm0
mov    (%rsi,%rbp,8),%rax
movq   %xmm0,(%rax,%rcx,8)
add    $0x1,%rbp
cmp    %rbp,%rdx
jne    1810 <Slfit+0x680>
jmp    1770 <Slfit+0x5e0>
pxor   %xmm0,%xmm0
xor    %ecx,%ecx
pxor   %xmm1,%xmm1
test   $0x1,%al
jne    12b6 <Slfit+0x126>
jmp    12e9 <Slfit+0x159>
mov    0x10(%rsp),%rdx
and    $0xfffffffe,%edx
neg    %rdx
xor    %ecx,%ecx
mov    $0x1,%eax
mov    (%rsp),%rdi
jmp    1876 <Slfit+0x6e6>
nopl   0x0(%rax,%rax,1)
lea    (%rdx,%rax,1),%rsi
add    $0x2,%rsi
add    $0x2,%rax
cmp    $0x1,%rsi
je     16e5 <Slfit+0x555>
cmpl   $0x0,(%rbx,%rax,4)
je     1892 <Slfit+0x702>
movslq %ecx,%rsi
add    $0x1,%ecx
mov    0x8(%rdi,%rsi,8),%rsi
movq   0x8(%rsi),%xmm0
movq   %xmm0,0x0(%rbp,%rax,8)
cmpl   $0x0,0x4(%rbx,%rax,4)
je     1860 <Slfit+0x6d0>
movslq %ecx,%rsi
add    $0x1,%ecx
mov    0x8(%rdi,%rsi,8),%rsi
movq   0x8(%rsi),%xmm0
movq   %xmm0,0x8(%rbp,%rax,8)
jmp    1860 <Slfit+0x6d0>

LLVM IR (-O0):
@.str = [42 x i8] c"lfit: There are no parameters to be fit.\0A\00"
define i32 @Slfit(double* %0, double* %1, double* %2, i32 %3, double* %4, i32* %5, i32 %6, double** %7, void (double, double*, i32)* %8) {
%10 = alloca i32
%11 = alloca double*
%12 = alloca double*
%13 = alloca double*
%14 = alloca i32
%15 = alloca double*
%16 = alloca i32*
%17 = alloca i32
%18 = alloca double**
%19 = alloca void (double, double*, i32)*
%20 = alloca i32
%21 = alloca i32
%22 = alloca double
%23 = alloca double
%24 = alloca double
%25 = alloca double**
%26 = alloca double*
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca i32
%33 = alloca i32
%34 = alloca i32
store double* %0, double** %11
store double* %1, double** %12
store double* %2, double** %13
store i32 %3, i32* %14
store double* %4, double** %15
store i32* %5, i32** %16
store i32 %6, i32* %17
store double** %7, double*** %18
store void (double, double*, i32)* %8, void (double, double*, i32)** %19
store i32 0, i32* %20
%35 = load i32, i32* %17
%36 = sext i32 %35 to i64
%37 = call double** @dmatrix(i64 1, i64 %36, i64 1, i64 1)
store double** %37, double*** %25
%38 = load i32, i32* %17
%39 = sext i32 %38 to i64
%40 = call double* @dblVector(i64 1, i64 %39)
store double* %40, double** %26
store i32 1, i32* %27
br label %41
41: ; preds = %56, %9
%42 = load i32, i32* %27
%43 = load i32, i32* %17
%44 = icmp sle i32 %42, %43
br i1 %44, label %45, label %59
45: ; preds = %41
%46 = load i32*, i32** %16
%47 = load i32, i32* %27
%48 = sext i32 %47 to i64
%49 = getelementptr inbounds i32, i32* %46, i64 %48
%50 = load i32, i32* %49
%51 = icmp ne i32 %50, 0
br i1 %51, label %52, label %55
52: ; preds = %45
%53 = load i32, i32* %20
%54 = add nsw i32 %53, 1
store i32 %54, i32* %20
br label %55
55: ; preds = %52, %45
br label %56
56: ; preds = %55
%57 = load i32, i32* %27
%58 = add nsw i32 %57, 1
store i32 %58, i32* %27
br label %41
59: ; preds = %41
%60 = load i32, i32* %20
%61 = icmp eq i32 %60, 0
br i1 %61, label %62, label %64
62: ; preds = %59
%63 = call i32 @printf(i8* getelementptr inbounds ([42 x i8], [42 x i8]* @.str, i64 0, i64 0))
store i32 1, i32* %10
br label %312
64: ; preds = %59
store i32 1, i32* %28
br label %65
65: ; preds = %93, %64
%66 = load i32, i32* %28
%67 = load i32, i32* %20
%68 = icmp sle i32 %66, %67
br i1 %68, label %69, label %96
69: ; preds = %65
store i32 1, i32* %29
br label %70
70: ; preds = %83, %69
%71 = load i32, i32* %29
%72 = load i32, i32* %20
%73 = icmp sle i32 %71, %72
br i1 %73, label %74, label %86
74: ; preds = %70
%75 = load double**, double*** %18
%76 = load i32, i32* %28
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds double*, double** %75, i64 %77
%79 = load double*, double** %78
%80 = load i32, i32* %29
%81 = sext i32 %80 to i64
%82 = getelementptr inbounds double, double* %79, i64 %81
store double 0.000000e+00, double* %82
br label %83
83: ; preds = %74
%84 = load i32, i32* %29
%85 = add nsw i32 %84, 1
store i32 %85, i32* %29
br label %70
86: ; preds = %70
%87 = load double**, double*** %25
%88 = load i32, i32* %28
%89 = sext i32 %88 to i64
%90 = getelementptr inbounds double*, double** %87, i64 %89
%91 = load double*, double** %90
%92 = getelementptr inbounds double, double* %91, i64 1
store double 0.000000e+00, double* %92
br label %93
93: ; preds = %86
%94 = load i32, i32* %28
%95 = add nsw i32 %94, 1
store i32 %95, i32* %28
br label %65
96: ; preds = %65
store i32 1, i32* %34
br label %97
97: ; preds = %227, %96
%98 = load i32, i32* %34
%99 = load i32, i32* %14
%100 = icmp sle i32 %98, %99
br i1 %100, label %101, label %230
101: ; preds = %97
%102 = load void (double, double*, i32)*, void (double, double*, i32)** %19
%103 = load double*, double** %11
%104 = load i32, i32* %34
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds double, double* %103, i64 %105
%107 = load double, double* %106
%108 = load double*, double** %26
%109 = load i32, i32* %17
%110 = load double*, double** %12
%111 = load i32, i32* %34
%112 = sext i32 %111 to i64
%113 = getelementptr inbounds double, double* %110, i64 %112
%114 = load double, double* %113
store double %114, double* %22
%115 = load i32, i32* %20
%116 = load i32, i32* %17
%117 = icmp slt i32 %115, %116
br i1 %117, label %118, label %149
118: ; preds = %101
store i32 1, i32* %30
br label %119
119: ; preds = %145, %118
%120 = load i32, i32* %30
%121 = load i32, i32* %17
%122 = icmp sle i32 %120, %121
br i1 %122, label %123, label %148
123: ; preds = %119
%124 = load i32*, i32** %16
%125 = load i32, i32* %30
%126 = sext i32 %125 to i64
%127 = getelementptr inbounds i32, i32* %124, i64 %126
%128 = load i32, i32* %127
%129 = icmp ne i32 %128, 0
br i1 %129, label %144, label %130
130: ; preds = %123
%131 = load double*, double** %15
%132 = load i32, i32* %30
%133 = sext i32 %132 to i64
%134 = getelementptr inbounds double, double* %131, i64 %133
%135 = load double, double* %134
%136 = load double*, double** %26
%137 = load i32, i32* %30
%138 = sext i32 %137 to i64
%139 = getelementptr inbounds double, double* %136, i64 %138
%140 = load double, double* %139
%141 = load double, double* %22
%142 = fneg double %135
%143 = call double @llvm.fmuladd.f64(double %142, double %140, double %141)
store double %143, double* %22
br label %144
144: ; preds = %130, %123
br label %145
145: ; preds = %144
%146 = load i32, i32* %30
%147 = add nsw i32 %146, 1
store i32 %147, i32* %30
br label %119
148: ; preds = %119
br label %149
149: ; preds = %148, %101
%150 = load double*, double** %13
%151 = load i32, i32* %34
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds double, double* %150, i64 %152
%154 = load double, double* %153
%155 = call double @sqrt(double %154)
%156 = fdiv double 1.000000e+00, %155
store double %156, double* %24
store i32 0, i32* %30
store i32 1, i32* %32
br label %157
157: ; preds = %223, %149
%158 = load i32, i32* %32
%159 = load i32, i32* %17
%160 = icmp sle i32 %158, %159
br i1 %160, label %161, label %226
161: ; preds = %157
%162 = load i32*, i32** %16
%163 = load i32, i32* %32
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds i32, i32* %162, i64 %164
%166 = load i32, i32* %165
%167 = icmp ne i32 %166, 0
br i1 %167, label %168, label %222
168: ; preds = %161
%169 = load double*, double** %26
%170 = load i32, i32* %32
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds double, double* %169, i64 %171
%173 = load double, double* %172
%174 = load double, double* %24
%175 = fmul double %173, %174
store double %175, double* %23
%176 = load i32, i32* %30
%177 = add nsw i32 %176, 1
store i32 %177, i32* %30
store i32 0, i32* %31
store i32 1, i32* %33
br label %178
178: ; preds = %208, %168
%179 = load i32, i32* %33
%180 = load i32, i32* %32
%181 = icmp sle i32 %179, %180
br i1 %181, label %182, label %211
182: ; preds = %178
%183 = load i32*, i32** %16
%184 = load i32, i32* %33
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds i32, i32* %183, i64 %185
%187 = load i32, i32* %186
%188 = icmp ne i32 %187, 0
br i1 %188, label %189, label %207
189: ; preds = %182
%190 = load double, double* %23
%191 = load double*, double** %26
%192 = load i32, i32* %33
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds double, double* %191, i64 %193
%195 = load double, double* %194
%196 = load double**, double*** %18
%197 = load i32, i32* %30
%198 = sext i32 %197 to i64
%199 = getelementptr inbounds double*, double** %196, i64 %198
%200 = load double*, double** %199
%201 = load i32, i32* %31
%202 = add nsw i32 %201, 1
store i32 %202, i32* %31
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds double, double* %200, i64 %203
%205 = load double, double* %204
%206 = call double @llvm.fmuladd.f64(double %190, double %195, double %205)
store double %206, double* %204
br label %207
207: ; preds = %189, %182
br label %208
208: ; preds = %207
%209 = load i32, i32* %33
%210 = add nsw i32 %209, 1
store i32 %210, i32* %33
br label %178
211: ; preds = %178
%212 = load double, double* %22
%213 = load double, double* %23
%214 = load double**, double*** %25
%215 = load i32, i32* %30
%216 = sext i32 %215 to i64
%217 = getelementptr inbounds double*, double** %214, i64 %216
%218 = load double*, double** %217
%219 = getelementptr inbounds double, double* %218, i64 1
%220 = load double, double* %219
%221 = call double @llvm.fmuladd.f64(double %212, double %213, double %220)
store double %221, double* %219
br label %222
222: ; preds = %211, %161
br label %223
223: ; preds = %222
%224 = load i32, i32* %32
%225 = add nsw i32 %224, 1
store i32 %225, i32* %32
br label %157
226: ; preds = %157
br label %227
227: ; preds = %226
%228 = load i32, i32* %34
%229 = add nsw i32 %228, 1
store i32 %229, i32* %34
br label %97
230: ; preds = %97
store i32 2, i32* %30
br label %231
231: ; preds = %262, %230
%232 = load i32, i32* %30
%233 = load i32, i32* %20
%234 = icmp sle i32 %232, %233
br i1 %234, label %235, label %265
235: ; preds = %231
store i32 1, i32* %31
br label %236
236: ; preds = %258, %235
%237 = load i32, i32* %31
%238 = load i32, i32* %30
%239 = icmp slt i32 %237, %238
br i1 %239, label %240, label %261
240: ; preds = %236
%241 = load double**, double*** %18
%242 = load i32, i32* %30
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds double*, double** %241, i64 %243
%245 = load double*, double** %244
%246 = load i32, i32* %31
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds double, double* %245, i64 %247
%249 = load double, double* %248
%250 = load double**, double*** %18
%251 = load i32, i32* %31
%252 = sext i32 %251 to i64
%253 = getelementptr inbounds double*, double** %250, i64 %252
%254 = load double*, double** %253
%255 = load i32, i32* %30
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds double, double* %254, i64 %256
store double %249, double* %257
br label %258
258: ; preds = %240
%259 = load i32, i32* %31
%260 = add nsw i32 %259, 1
store i32 %260, i32* %31
br label %236
261: ; preds = %236
br label %262
262: ; preds = %261
%263 = load i32, i32* %30
%264 = add nsw i32 %263, 1
store i32 %264, i32* %30
br label %231
265: ; preds = %231
%266 = load double**, double*** %18
%267 = load i32, i32* %20
%268 = load double**, double*** %25
%269 = call i32 @Sgaussj(double** %266, i32 %267, double** %268, i32 1)
store i32 %269, i32* %21
%270 = icmp ne i32 %269, 0
br i1 %270, label %271, label %273
271: ; preds = %265
%272 = load i32, i32* %21
store i32 %272, i32* %10
br label %312
273: ; preds = %265
store i32 0, i32* %30
store i32 1, i32* %32
br label %274
274: ; preds = %299, %273
%275 = load i32, i32* %32
%276 = load i32, i32* %17
%277 = icmp sle i32 %275, %276
br i1 %277, label %278, label %302
278: ; preds = %274
%279 = load i32*, i32** %16
%280 = load i32, i32* %32
%281 = sext i32 %280 to i64
%282 = getelementptr inbounds i32, i32* %279, i64 %281
%283 = load i32, i32* %282
%284 = icmp ne i32 %283, 0
br i1 %284, label %285, label %298
285: ; preds = %278
%286 = load double**, double*** %25
%287 = load i32, i32* %30
%288 = add nsw i32 %287, 1
store i32 %288, i32* %30
%289 = sext i32 %288 to i64
%290 = getelementptr inbounds double*, double** %286, i64 %289
%291 = load double*, double** %290
%292 = getelementptr inbounds double, double* %291, i64 1
%293 = load double, double* %292
%294 = load double*, double** %15
%295 = load i32, i32* %32
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds double, double* %294, i64 %296
store double %293, double* %297
br label %298
298: ; preds = %285, %278
br label %299
299: ; preds = %298
%300 = load i32, i32* %32
%301 = add nsw i32 %300, 1
store i32 %301, i32* %32
br label %274
302: ; preds = %274
%303 = load double**, double*** %18
%304 = load i32, i32* %17
%305 = load i32*, i32** %16
%306 = load i32, i32* %20
%307 = call i32 @Scovsrt(double** %303, i32 %304, i32* %305, i32 %306)
%308 = load double*, double** %26
%309 = call i32 @free_dblVector(double* %308, i64 1)
%310 = load double**, double*** %25
%311 = call i32 @free_dmatrix(double** %310, i64 1, i64 1)
store i32 0, i32* %10
br label %312
312: ; preds = %302, %271, %62
%313 = load i32, i32* %10
ret i32 %313
}

LLVM IR (-O2):
@str = [41 x i8] c"lfit: There are no parameters to be fit.\00"
define i32 @Slfit(double* nocapture %0, double* nocapture %1, double* nocapture %2, i32 %3, double* nocapture %4, i32* %5, i32 %6, double** %7, void (double, double*, i32)* nocapture %8) {
%10 = sext i32 %6 to i64
%11 = tail call double** @dmatrix(i64 1, i64 %10, i64 1, i64 1)
%12 = tail call double* @dblVector(i64 1, i64 %10)
%13 = icmp slt i32 %6, 1
br i1 %13, label %117, label %14
14: ; preds = %9
%15 = add nuw i32 %6, 1
%16 = zext i32 %15 to i64
%17 = add nsw i64 %16, -1
%18 = icmp ult i64 %17, 8
br i1 %18, label %90, label %19
19: ; preds = %14
%20 = and i64 %17, -8
%21 = or i64 %20, 1
%22 = add nsw i64 %20, -8
%23 = lshr exact i64 %22, 3
%24 = add nuw nsw i64 %23, 1
%25 = and i64 %24, 1
%26 = icmp eq i64 %22, 0
br i1 %26, label %63, label %27
27: ; preds = %19
%28 = and i64 %24, 4611686018427387902
br label %29
29: ; preds = %29, %27
%30 = phi i64 [ 0, %27 ], [ %60, %29 ]
%31 = phi <4 x i32> [ zeroinitializer, %27 ], [ %58, %29 ]
%32 = phi <4 x i32> [ zeroinitializer, %27 ], [ %59, %29 ]
%33 = phi i64 [ 0, %27 ], [ %61, %29 ]
%34 = or i64 %30, 1
%35 = getelementptr inbounds i32, i32* %5, i64 %34
%36 = bitcast i32* %35 to <4 x i32>*
%37 = load <4 x i32>, <4 x i32>* %36
%38 = getelementptr inbounds i32, i32* %35, i64 4
%39 = bitcast i32* %38 to <4 x i32>*
%40 = load <4 x i32>, <4 x i32>* %39
%41 = icmp ne <4 x i32> %37, zeroinitializer
%42 = icmp ne <4 x i32> %40, zeroinitializer
%43 = zext <4 x i1> %41 to <4 x i32>
%44 = zext <4 x i1> %42 to <4 x i32>
%45 = add <4 x i32> %31, %43
%46 = add <4 x i32> %32, %44
%47 = or i64 %30, 9
%48 = getelementptr inbounds i32, i32* %5, i64 %47
%49 = bitcast i32* %48 to <4 x i32>*
%50 = load <4 x i32>, <4 x i32>* %49
%51 = getelementptr inbounds i32, i32* %48, i64 4
%52 = bitcast i32* %51 to <4 x i32>*
%53 = load <4 x i32>, <4 x i32>* %52
%54 = icmp ne <4 x i32> %50, zeroinitializer
%55 = icmp ne <4 x i32> %53, zeroinitializer
%56 = zext <4 x i1> %54 to <4 x i32>
%57 = zext <4 x i1> %55 to <4 x i32>
%58 = add <4 x i32> %45, %56
%59 = add <4 x i32> %46, %57
%60 = add nuw i64 %30, 16
%61 = add i64 %33, 2
%62 = icmp eq i64 %61, %28
br i1 %62, label %63, label %29
63: ; preds = %29, %19
%64 = phi <4 x i32> [ undef, %19 ], [ %58, %29 ]
%65 = phi <4 x i32> [ undef, %19 ], [ %59, %29 ]
%66 = phi i64 [ 0, %19 ], [ %60, %29 ]
%67 = phi <4 x i32> [ zeroinitializer, %19 ], [ %58, %29 ]
%68 = phi <4 x i32> [ zeroinitializer, %19 ], [ %59, %29 ]
%69 = icmp eq i64 %25, 0
br i1 %69, label %84, label %70
70: ; preds = %63
%71 = or i64 %66, 1
%72 = getelementptr inbounds i32, i32* %5, i64 %71
%73 = bitcast i32* %72 to <4 x i32>*
%74 = load <4 x i32>, <4 x i32>* %73
%75 = getelementptr inbounds i32, i32* %72, i64 4
%76 = bitcast i32* %75 to <4 x i32>*
%77 = load <4 x i32>, <4 x i32>* %76
%78 = icmp ne <4 x i32> %74, zeroinitializer
%79 = icmp ne <4 x i32> %77, zeroinitializer
%80 = zext <4 x i1> %78 to <4 x i32>
%81 = zext <4 x i1> %79 to <4 x i32>
%82 = add <4 x i32> %67, %80
%83 = add <4 x i32> %68, %81
br label %84
84: ; preds = %63, %70
%85 = phi <4 x i32> [ %64, %63 ], [ %82, %70 ]
%86 = phi <4 x i32> [ %65, %63 ], [ %83, %70 ]
%87 = add <4 x i32> %86, %85
%88 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %87)
%89 = icmp eq i64 %17, %20
br i1 %89, label %93, label %90
90: ; preds = %14, %84
%91 = phi i64 [ 1, %14 ], [ %21, %84 ]
%92 = phi i32 [ 0, %14 ], [ %88, %84 ]
br label %107
93: ; preds = %107, %84
%94 = phi i32 [ %88, %84 ], [ %114, %107 ]
%95 = icmp eq i32 %94, 0
br i1 %95, label %117, label %96
96: ; preds = %93
%97 = zext i32 %94 to i64
%98 = shl nuw nsw i64 %97, 3
%99 = add nuw i32 %94, 1
%100 = zext i32 %99 to i64
%101 = add nsw i64 %100, -1
%102 = add nsw i64 %100, -2
%103 = and i64 %101, 3
%104 = icmp ult i64 %102, 3
br i1 %104, label %119, label %105
105: ; preds = %96
%106 = and i64 %101, -4
br label %148
107: ; preds = %90, %107
%108 = phi i64 [ %115, %107 ], [ %91, %90 ]
%109 = phi i32 [ %114, %107 ], [ %92, %90 ]
%110 = getelementptr inbounds i32, i32* %5, i64 %108
%111 = load i32, i32* %110
%112 = icmp ne i32 %111, 0
%113 = zext i1 %112 to i32
%114 = add nuw nsw i32 %109, %113
%115 = add nuw nsw i64 %108, 1
%116 = icmp eq i64 %115, %16
br i1 %116, label %93, label %107
117: ; preds = %9, %93
%118 = tail call i32 @puts(i8* dereferenceable(1) getelementptr inbounds ([41 x i8], [41 x i8]* @str, i64 0, i64 0))
br label %417
119: ; preds = %148, %96
%120 = phi i64 [ 1, %96 ], [ %182, %148 ]
%121 = icmp eq i64 %103, 0
br i1 %121, label %135, label %122
122: ; preds = %119, %122
%123 = phi i64 [ %132, %122 ], [ %120, %119 ]
%124 = phi i64 [ %133, %122 ], [ 0, %119 ]
%125 = getelementptr inbounds double*, double** %7, i64 %123
%126 = load double*, double** %125
%127 = getelementptr double, double* %126, i64 1
%128 = bitcast double* %127 to i8*
%129 = getelementptr inbounds double*, double** %11, i64 %123
%130 = load double*, double** %129
%131 = getelementptr inbounds double, double* %130, i64 1
store double 0.000000e+00, double* %131
%132 = add nuw nsw i64 %123, 1
%133 = add i64 %124, 1
%134 = icmp eq i64 %133, %103
br i1 %134, label %135, label %122
135: ; preds = %122, %119
%136 = icmp slt i32 %3, 1
br i1 %136, label %185, label %137
137: ; preds = %135
%138 = icmp sge i32 %94, %6
%139 = add i32 %6, 1
%140 = add nuw i32 %3, 1
%141 = zext i32 %140 to i64
%142 = or i1 %138, %13
%143 = zext i32 %139 to i64
%144 = and i64 %17, 1
%145 = icmp eq i32 %15, 2
%146 = and i64 %17, -2
%147 = icmp eq i64 %144, 0
br label %190
148: ; preds = %148, %105
%149 = phi i64 [ 1, %105 ], [ %182, %148 ]
%150 = phi i64 [ 0, %105 ], [ %183, %148 ]
%151 = getelementptr inbounds double*, double** %7, i64 %149
%152 = load double*, double** %151
%153 = getelementptr double, double* %152, i64 1
%154 = bitcast double* %153 to i8*
%155 = getelementptr inbounds double*, double** %11, i64 %149
%156 = load double*, double** %155
%157 = getelementptr inbounds double, double* %156, i64 1
store double 0.000000e+00, double* %157
%158 = add nuw nsw i64 %149, 1
%159 = getelementptr inbounds double*, double** %7, i64 %158
%160 = load double*, double** %159
%161 = getelementptr double, double* %160, i64 1
%162 = bitcast double* %161 to i8*
%163 = getelementptr inbounds double*, double** %11, i64 %158
%164 = load double*, double** %163
%165 = getelementptr inbounds double, double* %164, i64 1
store double 0.000000e+00, double* %165
%166 = add nuw nsw i64 %149, 2
%167 = getelementptr inbounds double*, double** %7, i64 %166
%168 = load double*, double** %167
%169 = getelementptr double, double* %168, i64 1
%170 = bitcast double* %169 to i8*
%171 = getelementptr inbounds double*, double** %11, i64 %166
%172 = load double*, double** %171
%173 = getelementptr inbounds double, double* %172, i64 1
store double 0.000000e+00, double* %173
%174 = add nuw nsw i64 %149, 3
%175 = getelementptr inbounds double*, double** %7, i64 %174
%176 = load double*, double** %175
%177 = getelementptr double, double* %176, i64 1
%178 = bitcast double* %177 to i8*
%179 = getelementptr inbounds double*, double** %11, i64 %174
%180 = load double*, double** %179
%181 = getelementptr inbounds double, double* %180, i64 1
store double 0.000000e+00, double* %181
%182 = add nuw nsw i64 %149, 4
%183 = add i64 %150, 4
%184 = icmp eq i64 %183, %106
br i1 %184, label %119, label %148
185: ; preds = %294, %135
%186 = icmp ult i32 %94, 2
br i1 %186, label %354, label %187
187: ; preds = %185
%188 = add nuw i32 %94, 1
%189 = zext i32 %188 to i64
br label %297
190: ; preds = %137, %294
%191 = phi i64 [ 1, %137 ], [ %295, %294 ]
%192 = getelementptr inbounds double, double* %0, i64 %191
%193 = load double, double* %192
tail call void %8(double %193, double* %12, i32 %6)
%194 = getelementptr inbounds double, double* %1, i64 %191
%195 = load double, double* %194
br i1 %142, label %244, label %196
196: ; preds = %190
br i1 %145, label %229, label %197
197: ; preds = %196, %224
%198 = phi i64 [ %226, %224 ], [ 1, %196 ]
%199 = phi double [ %225, %224 ], [ %195, %196 ]
%200 = phi i64 [ %227, %224 ], [ 0, %196 ]
%201 = getelementptr inbounds i32, i32* %5, i64 %198
%202 = load i32, i32* %201
%203 = icmp eq i32 %202, 0
br i1 %203, label %204, label %211
204: ; preds = %197
%205 = getelementptr inbounds double, double* %4, i64 %198
%206 = load double, double* %205
%207 = getelementptr inbounds double, double* %12, i64 %198
%208 = load double, double* %207
%209 = fneg double %206
%210 = tail call double @llvm.fmuladd.f64(double %209, double %208, double %199)
br label %211
211: ; preds = %197, %204
%212 = phi double [ %199, %197 ], [ %210, %204 ]
%213 = add nuw nsw i64 %198, 1
%214 = getelementptr inbounds i32, i32* %5, i64 %213
%215 = load i32, i32* %214
%216 = icmp eq i32 %215, 0
br i1 %216, label %217, label %224
217: ; preds = %211
%218 = getelementptr inbounds double, double* %4, i64 %213
%219 = load double, double* %218
%220 = getelementptr inbounds double, double* %12, i64 %213
%221 = load double, double* %220
%222 = fneg double %219
%223 = tail call double @llvm.fmuladd.f64(double %222, double %221, double %212)
br label %224
224: ; preds = %217, %211
%225 = phi double [ %212, %211 ], [ %223, %217 ]
%226 = add nuw nsw i64 %198, 2
%227 = add i64 %200, 2
%228 = icmp eq i64 %227, %146
br i1 %228, label %229, label %197
229: ; preds = %224, %196
%230 = phi double [ undef, %196 ], [ %225, %224 ]
%231 = phi i64 [ 1, %196 ], [ %226, %224 ]
%232 = phi double [ %195, %196 ], [ %225, %224 ]
br i1 %147, label %244, label %233
233: ; preds = %229
%234 = getelementptr inbounds i32, i32* %5, i64 %231
%235 = load i32, i32* %234
%236 = icmp eq i32 %235, 0
br i1 %236, label %237, label %244
237: ; preds = %233
%238 = getelementptr inbounds double, double* %4, i64 %231
%239 = load double, double* %238
%240 = getelementptr inbounds double, double* %12, i64 %231
%241 = load double, double* %240
%242 = fneg double %239
%243 = tail call double @llvm.fmuladd.f64(double %242, double %241, double %232)
br label %244
244: ; preds = %229, %237, %233, %190
%245 = phi double [ %195, %190 ], [ %230, %229 ], [ %232, %233 ], [ %243, %237 ]
%246 = getelementptr inbounds double, double* %2, i64 %191
%247 = load double, double* %246
%248 = tail call double @sqrt(double %247)
%249 = fdiv double 1.000000e+00, %248
br i1 %13, label %294, label %250
250: ; preds = %244, %289
%251 = phi i64 [ %291, %289 ], [ 1, %244 ]
%252 = phi i64 [ %292, %289 ], [ 2, %244 ]
%253 = phi i32 [ %290, %289 ], [ 0, %244 ]
%254 = getelementptr inbounds i32, i32* %5, i64 %251
%255 = load i32, i32* %254
%256 = icmp eq i32 %255, 0
br i1 %256, label %289, label %257
257: ; preds = %250
%258 = getelementptr inbounds double, double* %12, i64 %251
%259 = load double, double* %258
%260 = fmul double %249, %259
%261 = add nsw i32 %253, 1
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds double*, double** %7, i64 %262
br label %264
264: ; preds = %257, %279
%265 = phi i64 [ 1, %257 ], [ %281, %279 ]
%266 = phi i32 [ 0, %257 ], [ %280, %279 ]
%267 = getelementptr inbounds i32, i32* %5, i64 %265
%268 = load i32, i32* %267
%269 = icmp eq i32 %268, 0
br i1 %269, label %279, label %270
270: ; preds = %264
%271 = getelementptr inbounds double, double* %12, i64 %265
%272 = load double, double* %271
%273 = load double*, double** %263
%274 = add nsw i32 %266, 1
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds double, double* %273, i64 %275
%277 = load double, double* %276
%278 = tail call double @llvm.fmuladd.f64(double %260, double %272, double %277)
store double %278, double* %276
br label %279
279: ; preds = %264, %270
%280 = phi i32 [ %274, %270 ], [ %266, %264 ]
%281 = add nuw nsw i64 %265, 1
%282 = icmp eq i64 %281, %252
br i1 %282, label %283, label %264
283: ; preds = %279
%284 = getelementptr inbounds double*, double** %11, i64 %262
%285 = load double*, double** %284
%286 = getelementptr inbounds double, double* %285, i64 1
%287 = load double, double* %286
%288 = tail call double @llvm.fmuladd.f64(double %245, double %260, double %287)
store double %288, double* %286
br label %289
289: ; preds = %250, %283
%290 = phi i32 [ %261, %283 ], [ %253, %250 ]
%291 = add nuw nsw i64 %251, 1
%292 = add nuw nsw i64 %252, 1
%293 = icmp eq i64 %291, %143
br i1 %293, label %294, label %250
294: ; preds = %289, %244
%295 = add nuw nsw i64 %191, 1
%296 = icmp eq i64 %295, %141
br i1 %296, label %185, label %190
297: ; preds = %187, %350
%298 = phi i64 [ 0, %187 ], [ %353, %350 ]
%299 = phi i64 [ 2, %187 ], [ %351, %350 ]
%300 = add i64 %298, 1
%301 = getelementptr inbounds double*, double** %7, i64 %299
%302 = load double*, double** %301
%303 = and i64 %300, 3
%304 = icmp ult i64 %298, 3
br i1 %304, label %336, label %305
305: ; preds = %297
%306 = and i64 %300, -4
br label %307
307: ; preds = %307, %305
%308 = phi i64 [ 1, %305 ], [ %333, %307 ]
%309 = phi i64 [ 0, %305 ], [ %334, %307 ]
%310 = getelementptr inbounds double, double* %302, i64 %308
%311 = load double, double* %310
%312 = getelementptr inbounds double*, double** %7, i64 %308
%313 = load double*, double** %312
%314 = getelementptr inbounds double, double* %313, i64 %299
store double %311, double* %314
%315 = add nuw nsw i64 %308, 1
%316 = getelementptr inbounds double, double* %302, i64 %315
%317 = load double, double* %316
%318 = getelementptr inbounds double*, double** %7, i64 %315
%319 = load double*, double** %318
%320 = getelementptr inbounds double, double* %319, i64 %299
store double %317, double* %320
%321 = add nuw nsw i64 %308, 2
%322 = getelementptr inbounds double, double* %302, i64 %321
%323 = load double, double* %322
%324 = getelementptr inbounds double*, double** %7, i64 %321
%325 = load double*, double** %324
%326 = getelementptr inbounds double, double* %325, i64 %299
store double %323, double* %326
%327 = add nuw nsw i64 %308, 3
%328 = getelementptr inbounds double, double* %302, i64 %327
%329 = load double, double* %328
%330 = getelementptr inbounds double*, double** %7, i64 %327
%331 = load double*, double** %330
%332 = getelementptr inbounds double, double* %331, i64 %299
store double %329, double* %332
%333 = add nuw nsw i64 %308, 4
%334 = add i64 %309, 4
%335 = icmp eq i64 %334, %306
br i1 %335, label %336, label %307
336: ; preds = %307, %297
%337 = phi i64 [ 1, %297 ], [ %333, %307 ]
%338 = icmp eq i64 %303, 0
br i1 %338, label %350, label %339
339: ; preds = %336, %339
%340 = phi i64 [ %347, %339 ], [ %337, %336 ]
%341 = phi i64 [ %348, %339 ], [ 0, %336 ]
%342 = getelementptr inbounds double, double* %302, i64 %340
%343 = load double, double* %342
%344 = getelementptr inbounds double*, double** %7, i64 %340
%345 = load double*, double** %344
%346 = getelementptr inbounds double, double* %345, i64 %299
store double %343, double* %346
%347 = add nuw nsw i64 %340, 1
%348 = add i64 %341, 1
%349 = icmp eq i64 %348, %303
br i1 %349, label %350, label %339
350: ; preds = %339, %336
%351 = add nuw nsw i64 %299, 1
%352 = icmp eq i64 %351, %189
%353 = add i64 %298, 1
br i1 %352, label %354, label %297
354: ; preds = %350, %185
%355 = tail call i32 @Sgaussj(double** %7, i32 %94, double** %11, i32 1)
%356 = icmp eq i32 %355, 0
br i1 %356, label %357, label %417
357: ; preds = %354
br i1 %13, label %413, label %358
358: ; preds = %357
%359 = and i64 %17, 1
%360 = icmp eq i32 %15, 2
br i1 %360, label %397, label %361
361: ; preds = %358
%362 = and i64 %17, -2
br label %363
363: ; preds = %392, %361
%364 = phi i64 [ 1, %361 ], [ %394, %392 ]
%365 = phi i32 [ 0, %361 ], [ %393, %392 ]
%366 = phi i64 [ 0, %361 ], [ %395, %392 ]
%367 = getelementptr inbounds i32, i32* %5, i64 %364
%368 = load i32, i32* %367
%369 = icmp eq i32 %368, 0
br i1 %369, label %378, label %370
370: ; preds = %363
%371 = add nsw i32 %365, 1
%372 = sext i32 %371 to i64
%373 = getelementptr inbounds double*, double** %11, i64 %372
%374 = load double*, double** %373
%375 = getelementptr inbounds double, double* %374, i64 1
%376 = load double, double* %375
%377 = getelementptr inbounds double, double* %4, i64 %364
store double %376, double* %377
br label %378
378: ; preds = %363, %370
%379 = phi i32 [ %371, %370 ], [ %365, %363 ]
%380 = add nuw nsw i64 %364, 1
%381 = getelementptr inbounds i32, i32* %5, i64 %380
%382 = load i32, i32* %381
%383 = icmp eq i32 %382, 0
br i1 %383, label %392, label %384
384: ; preds = %378
%385 = add nsw i32 %379, 1
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds double*, double** %11, i64 %386
%388 = load double*, double** %387
%389 = getelementptr inbounds double, double* %388, i64 1
%390 = load double, double* %389
%391 = getelementptr inbounds double, double* %4, i64 %380
store double %390, double* %391
br label %392
392: ; preds = %384, %378
%393 = phi i32 [ %385, %384 ], [ %379, %378 ]
%394 = add nuw nsw i64 %364, 2
%395 = add i64 %366, 2
%396 = icmp eq i64 %395, %362
br i1 %396, label %397, label %363
397: ; preds = %392, %358
%398 = phi i64 [ 1, %358 ], [ %394, %392 ]
%399 = phi i32 [ 0, %358 ], [ %393, %392 ]
%400 = icmp eq i64 %359, 0
br i1 %400, label %413, label %401
401: ; preds = %397
%402 = getelementptr inbounds i32, i32* %5, i64 %398
%403 = load i32, i32* %402
%404 = icmp eq i32 %403, 0
br i1 %404, label %413, label %405
405: ; preds = %401
%406 = add nsw i32 %399, 1
%407 = sext i32 %406 to i64
%408 = getelementptr inbounds double*, double** %11, i64 %407
%409 = load double*, double** %408
%410 = getelementptr inbounds double, double* %409, i64 1
%411 = load double, double* %410
%412 = getelementptr inbounds double, double* %4, i64 %398
store double %411, double* %412
br label %413
413: ; preds = %397, %405, %401, %357
%414 = tail call i32 @Scovsrt(double** %7, i32 %6, i32* %5, i32 %94)
%415 = tail call i32 @free_dblVector(double* %12, i64 1)
%416 = tail call i32 @free_dmatrix(double** %11, i64 1, i64 1)
br label %417
417: ; preds = %413, %354, %117
%418 = phi i32 [ 1, %117 ], [ 0, %413 ], [ %355, %354 ]
ret i32 %418
}