#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*/ covsrt(float **, int, int *, int);
float **fmatrix(int, int, int, int);
int /*<<< orphan*/ free_fmatrix(float **, int, int, int, int);
int /*<<< orphan*/ free_fvector(float *, int, int);
float *fvector(int, int);
int /*<<< orphan*/ gaussj(float **, int, float **, int);
int /*<<< orphan*/ mrqcofx(float *, int, float *, float *, int, float *, int *,
                           int, float **, float *, float *,
                           void (*)(float *, float *, float *, float *, int));
void mrqminx(float x[], int xdim, float y[], float sig[], int ndata, float a[],
             int ia[], int ma, float **covar, float **alpha, float *chisq,
             void (*funcs)(float *, float[], float *, float[], int),
             float *alamda) {
  int j, k, l, m;
  static int mfit;
  static float ochisq, *atry, *beta, *da, **oneda;
  if (*alamda < 0.0) {
    atry = fvector(1, ma);
    beta = fvector(1, ma);
    da = fvector(1, ma);
    for (mfit = 0, j = 1; j <= ma; j++)
      if (ia[j])
        mfit++;
    oneda = fmatrix(1, mfit, 1, 1);
    *alamda = 0.001;
    mrqcofx(x, xdim, y, sig, ndata, a, ia, ma, alpha, beta, chisq, funcs);
    ochisq = (*chisq);
    for (j = 1; j <= ma; j++)
      atry[j] = a[j];
  }
  for (j = 0, l = 1; l <= ma; l++) {
    if (ia[l]) {
      for (j++, k = 0, m = 1; m <= ma; m++) {
        if (ia[m]) {
          k++;
          covar[j][k] = alpha[j][k];
        }
      }
      covar[j][j] = alpha[j][j] * (1.0 + (*alamda));
      oneda[j][1] = beta[j];
    }
  }
  gaussj(covar, mfit, oneda, 1);
  for (j = 1; j <= mfit; j++)
    da[j] = oneda[j][1];
  if (*alamda == 0.0) {
    covsrt(covar, ma, ia, mfit);
    free_fmatrix(oneda, 1, mfit, 1, 1);
    free_fvector(da, 1, ma);
    free_fvector(beta, 1, ma);
    free_fvector(atry, 1, ma);
    return;
  }
  for (j = 0, l = 1; l <= ma; l++)
    if (ia[l])
      atry[l] = a[l] + da[++j];
  mrqcofx(x, xdim, y, sig, ndata, atry, ia, ma, covar, da, chisq, funcs);
  if (*chisq < ochisq) {
    *alamda *= 0.1;
    ochisq = (*chisq);
    for (j = 0, l = 1; l <= ma; l++) {
      if (ia[l]) {
        for (j++, k = 0, m = 1; m <= ma; m++) {
          if (ia[m]) {
            k++;
            alpha[j][k] = covar[j][k];
          }
        }
        beta[j] = da[j];
        a[l] = atry[l];
      }
    }
  } else {
    *alamda *= 10.0;
    *chisq = ochisq;
  }
}


x86 assembly (clang, -O0):
<mrqminx>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %rbx
sub    $0x78,%rsp
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x20(%rbp)
mov    %esi,-0x24(%rbp)
mov    %rdx,-0x30(%rbp)
mov    %rcx,-0x38(%rbp)
mov    %r8d,-0x3c(%rbp)
mov    %r9,-0x48(%rbp)
mov    0x40(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1327 <mrqminx+0x1b7>
mov    0x18(%rbp),%esi
mov    $0x1,%edi
call   1070 <fvector@plt>
mov    %rax,0x2e8c(%rip)
mov    0x18(%rbp),%esi
mov    $0x1,%edi
call   1070 <fvector@plt>
mov    %rax,0x2e80(%rip)
mov    0x18(%rbp),%esi
mov    $0x1,%edi
call   1070 <fvector@plt>
mov    %rax,0x2e74(%rip)
movl   $0x0,0x2e52(%rip)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     1255 <mrqminx+0xe5>
mov    0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1242 <mrqminx+0xd2>
mov    0x2e27(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2e1e(%rip)
jmp    1247 <mrqminx+0xd7>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1215 <mrqminx+0xa5>
mov    0x2e05(%rip),%esi
mov    $0x1,%ecx
mov    %ecx,%edi
mov    %ecx,%edx
call   1090 <fmatrix@plt>
mov    %rax,0x2e10(%rip)
mov    0x40(%rbp),%rax
movss  0xd84(%rip),%xmm0
movss  %xmm0,(%rax)
mov    -0x20(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x3c(%rbp),%r8d
mov    -0x48(%rbp),%r9
mov    0x10(%rbp),%r15
mov    0x18(%rbp),%r14d
mov    0x28(%rbp),%rbx
mov    0x2dc6(%rip),%r11
mov    0x30(%rbp),%r10
mov    0x38(%rbp),%rax
mov    %r15,(%rsp)
mov    %r14d,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1080 <mrqcofx@plt>
mov    0x30(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,0x2d80(%rip)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     1322 <mrqminx+0x1b2>
mov    -0x48(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x2d5d(%rip),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    12eb <mrqminx+0x17b>
jmp    1327 <mrqminx+0x1b7>
movl   $0x0,-0x4c(%rbp)
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     1453 <mrqminx+0x2e3>
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1440 <mrqminx+0x2d0>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     13ce <mrqminx+0x25e>
mov    0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     13bb <mrqminx+0x24b>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    13c0 <mrqminx+0x250>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    136a <mrqminx+0x1fa>
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x40(%rbp),%rax
movss  (%rax),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xc1d(%rip),%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x2c4d(%rip),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x2c4d(%rip),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x4(%rax)
jmp    1445 <mrqminx+0x2d5>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1335 <mrqminx+0x1c5>
mov    0x20(%rbp),%rdi
mov    0x2c03(%rip),%esi
mov    0x2c1c(%rip),%rdx
mov    $0x1,%ecx
call   1040 <gaussj@plt>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x2be2(%rip),%eax
jg     14b6 <mrqminx+0x346>
mov    0x2bf5(%rip),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x4(%rax),%xmm0
mov    0x2bd9(%rip),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1475 <mrqminx+0x305>
mov    0x40(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    154a <mrqminx+0x3da>
jp     154a <mrqminx+0x3da>
mov    0x20(%rbp),%rdi
mov    0x18(%rbp),%esi
mov    0x10(%rbp),%rdx
mov    0x2b7a(%rip),%ecx
call   1050 <covsrt@plt>
mov    0x2b8e(%rip),%rdi
mov    0x2b68(%rip),%edx
mov    $0x1,%r8d
mov    %r8d,%esi
mov    %r8d,%ecx
call   1060 <free_fmatrix@plt>
mov    0x2b68(%rip),%rdi
mov    0x18(%rbp),%edx
mov    $0x1,%esi
call   1030 <free_fvector@plt>
mov    0x2b4c(%rip),%rdi
mov    0x18(%rbp),%edx
mov    $0x1,%esi
call   1030 <free_fvector@plt>
mov    0x2b30(%rip),%rdi
mov    0x18(%rbp),%edx
mov    $0x1,%esi
call   1030 <free_fvector@plt>
jmp    178a <mrqminx+0x61a>
movl   $0x0,-0x4c(%rbp)
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     15be <mrqminx+0x44e>
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     15ab <mrqminx+0x43b>
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x2aee(%rip),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x4c(%rbp)
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x2ac6(%rip),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    15b0 <mrqminx+0x440>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    1558 <mrqminx+0x3e8>
mov    -0x20(%rbp),%rdi
mov    -0x24(%rbp),%esi
mov    -0x30(%rbp),%rdx
mov    -0x38(%rbp),%rcx
mov    -0x3c(%rbp),%r8d
mov    0x2a90(%rip),%r9
mov    0x10(%rbp),%r15
mov    0x18(%rbp),%r14d
mov    0x20(%rbp),%rbx
mov    0x2a8d(%rip),%r11
mov    0x30(%rbp),%r10
mov    0x38(%rbp),%rax
mov    %r15,(%rsp)
mov    %r14d,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
call   1080 <mrqcofx@plt>
mov    0x30(%rbp),%rax
movss  (%rax),%xmm1
movss  0x2a3f(%rip),%xmm0
ucomiss %xmm1,%xmm0
jbe    175a <mrqminx+0x5ea>
mov    0x40(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x9ce(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    0x30(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,0x2a06(%rip)
movl   $0x0,-0x4c(%rbp)
movl   $0x1,-0x54(%rbp)
mov    -0x54(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     1755 <mrqminx+0x5e5>
mov    0x10(%rbp),%rax
movslq -0x54(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1742 <mrqminx+0x5d2>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     1705 <mrqminx+0x595>
mov    0x10(%rbp),%rax
movslq -0x58(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     16f2 <mrqminx+0x582>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    0x20(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x28(%rbp),%rax
movslq -0x4c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    16f7 <mrqminx+0x587>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    16a1 <mrqminx+0x531>
mov    0x296c(%rip),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x2954(%rip),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x293c(%rip),%rax
movslq -0x54(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
movslq -0x54(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    1747 <mrqminx+0x5d7>
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
jmp    166c <mrqminx+0x4fc>
jmp    178a <mrqminx+0x61a>
mov    0x40(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x89a(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax)
movss  0x28e2(%rip),%xmm0
mov    0x30(%rbp),%rax
movss  %xmm0,(%rax)
add    $0x78,%rsp
pop    %rbx
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<mrqminx>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r9,0x18(%rsp)
mov    %r8d,0x24(%rsp)
mov    %rcx,0x50(%rsp)
mov    %rdx,0x48(%rsp)
mov    %esi,0x20(%rsp)
mov    %rdi,0x38(%rsp)
mov    0xd0(%rsp),%r14
mov    0xc8(%rsp),%rax
mov    %rax,0x40(%rsp)
mov    0xc0(%rsp),%rax
mov    %rax,0x58(%rsp)
mov    0xb8(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    0xb0(%rsp),%r12
mov    0xa8(%rsp),%esi
mov    0xa0(%rsp),%rbx
xorps  %xmm0,%xmm0
ucomiss (%r14),%xmm0
mov    %rsi,0x28(%rsp)
mov    %r14,0x30(%rsp)
jbe    1568 <mrqminx+0x3f8>
mov    $0x1,%edi
call   1070 <fvector@plt>
mov    %rax,0x2e5f(%rip)
mov    $0x1,%edi
mov    0x28(%rsp),%rsi
call   1070 <fvector@plt>
mov    %rax,0x2e51(%rip)
mov    $0x1,%edi
mov    0x28(%rsp),%rsi
call   1070 <fvector@plt>
mov    0x28(%rsp),%rbp
mov    %rax,0x2e3e(%rip)
movl   $0x0,0x2e1c(%rip)
test   %ebp,%ebp
jle    131d <mrqminx+0x1ad>
mov    %ebp,%r15d
cmp    $0x1,%ebp
jne    1395 <mrqminx+0x225>
xor    %esi,%esi
mov    $0x1,%eax
test   $0x1,%r15b
je     1274 <mrqminx+0x104>
cmpl   $0x0,(%rbx,%rax,4)
je     1274 <mrqminx+0x104>
add    $0x1,%esi
mov    %esi,0x2dec(%rip)
mov    $0x1,%edi
mov    $0x1,%edx
mov    $0x1,%ecx
call   1090 <fmatrix@plt>
mov    %rax,0x2df1(%rip)
movl   $0x3a83126f,(%r14)
mov    0x38(%rsp),%rdi
mov    0x20(%rsp),%esi
mov    0x48(%rsp),%rdx
mov    0x50(%rsp),%rcx
mov    0x24(%rsp),%r8d
mov    0x18(%rsp),%r9
push   0x40(%rsp)
mov    0x60(%rsp),%r14
push   %r14
push   0x2dac(%rip)
push   0x28(%rsp)
mov    0x48(%rsp),%rbp
push   %rbp
push   %rbx
call   1080 <mrqcofx@plt>
mov    %rbp,%rsi
add    $0x30,%rsp
movss  (%r14),%xmm0
movss  %xmm0,0x2d7c(%rip)
test   %esi,%esi
jle    13e7 <mrqminx+0x277>
add    $0x1,%r15
mov    0x2d6d(%rip),%rax
lea    -0x1(%r15),%r8
mov    $0x1,%ecx
cmp    $0x8,%r8
jae    13f6 <mrqminx+0x286>
mov    0x18(%rsp),%rbp
mov    0x30(%rsp),%r14
jmp    14f2 <mrqminx+0x382>
mov    $0x1,%edi
xor    %esi,%esi
mov    $0x1,%edx
mov    $0x1,%ecx
call   1090 <fmatrix@plt>
mov    %rax,0x2d46(%rip)
movl   $0x3a83126f,(%r14)
mov    0x38(%rsp),%rdi
mov    0x20(%rsp),%esi
mov    0x48(%rsp),%rdx
mov    0x50(%rsp),%rcx
mov    0x24(%rsp),%r8d
mov    0x18(%rsp),%r9
push   0x40(%rsp)
mov    0x60(%rsp),%r14
push   %r14
push   0x2d01(%rip)
push   0x28(%rsp)
push   %rbp
push   %rbx
call   1080 <mrqcofx@plt>
add    $0x30,%rsp
movss  (%r14),%xmm0
mov    0x30(%rsp),%r14
movss  %xmm0,0x2cd4(%rip)
jmp    16c3 <mrqminx+0x553>
mov    %r15d,%ecx
and    $0xfffffffe,%ecx
neg    %rcx
xor    %esi,%esi
mov    $0x1,%eax
jmp    13c6 <mrqminx+0x256>
nopw   0x0(%rax,%rax,1)
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
je     125f <mrqminx+0xef>
cmpl   $0x0,(%rbx,%rax,4)
je     13d5 <mrqminx+0x265>
add    $0x1,%esi
mov    %esi,0x2c8b(%rip)
cmpl   $0x0,0x4(%rbx,%rax,4)
je     13b0 <mrqminx+0x240>
add    $0x1,%esi
mov    %esi,0x2c7b(%rip)
jmp    13b0 <mrqminx+0x240>
movb   $0x1,0xf(%rsp)
mov    0x30(%rsp),%r14
jmp    16c8 <mrqminx+0x558>
lea    0x4(%rax),%rdx
mov    0x18(%rsp),%rbp
lea    0x0(,%r15,4),%rdi
add    %rbp,%rdi
cmp    %rdi,%rdx
mov    0x30(%rsp),%r14
jae    1425 <mrqminx+0x2b5>
lea    (%rax,%r15,4),%rdx
lea    0x4(%rbp),%rdi
cmp    %rdx,%rdi
jb     14f2 <mrqminx+0x382>
mov    %r8,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%r9d
and    $0x3,%r9d
cmp    $0x18,%rdi
jae    144c <mrqminx+0x2dc>
xor    %edi,%edi
jmp    14ba <mrqminx+0x34a>
and    $0xfffffffffffffffc,%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups 0x4(%rbp,%rdi,4),%xmm0
movups 0x14(%rbp,%rdi,4),%xmm1
movups %xmm0,0x4(%rax,%rdi,4)
movups %xmm1,0x14(%rax,%rdi,4)
movups 0x24(%rbp,%rdi,4),%xmm0
movups 0x34(%rbp,%rdi,4),%xmm1
movups %xmm0,0x24(%rax,%rdi,4)
movups %xmm1,0x34(%rax,%rdi,4)
movups 0x44(%rbp,%rdi,4),%xmm0
movups 0x54(%rbp,%rdi,4),%xmm1
movups %xmm0,0x44(%rax,%rdi,4)
movups %xmm1,0x54(%rax,%rdi,4)
movups 0x64(%rbp,%rdi,4),%xmm0
movups 0x74(%rbp,%rdi,4),%xmm1
movups %xmm0,0x64(%rax,%rdi,4)
movups %xmm1,0x74(%rax,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rdx
jne    1460 <mrqminx+0x2f0>
test   %r9,%r9
je     14e9 <mrqminx+0x379>
nop
lea    0x0(,%rdi,4),%rdx
or     $0x4,%rdx
movups 0x0(%rbp,%rdx,1),%xmm0
movups 0x10(%rbp,%rdx,1),%xmm1
movups %xmm0,(%rax,%rdx,1)
movups %xmm1,0x10(%rax,%rdx,1)
add    $0x8,%rdi
add    $0xffffffffffffffff,%r9
jne    14c0 <mrqminx+0x350>
cmp    %rcx,%r8
je     1568 <mrqminx+0x3f8>
or     $0x1,%rcx
mov    %r15d,%edi
sub    %ecx,%edi
mov    %rcx,%rdx
not    %rdx
add    %r15,%rdx
and    $0x3,%rdi
je     1525 <mrqminx+0x3b5>
cs nopw 0x0(%rax,%rax,1)
movss  0x0(%rbp,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    1510 <mrqminx+0x3a0>
cmp    $0x3,%rdx
jb     1568 <mrqminx+0x3f8>
nopl   0x0(%rax,%rax,1)
movss  0x0(%rbp,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  0x4(%rbp,%rcx,4),%xmm0
movss  %xmm0,0x4(%rax,%rcx,4)
movss  0x8(%rbp,%rcx,4),%xmm0
movss  %xmm0,0x8(%rax,%rcx,4)
movss  0xc(%rbp,%rcx,4),%xmm0
movss  %xmm0,0xc(%rax,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r15
jne    1530 <mrqminx+0x3c0>
test   %esi,%esi
setle  0xf(%rsp)
jle    16c3 <mrqminx+0x553>
mov    0x2af4(%rip),%rax
mov    %rax,0x60(%rsp)
mov    0x2af8(%rip),%r9
mov    %esi,%r10d
lea    0x1(%r10),%r11
mov    %r10d,%edi
and    $0xfffffffe,%edi
neg    %rdi
xor    %r8d,%r8d
mov    $0x1,%ecx
movsd  0xa58(%rip),%xmm0
jmp    1608 <mrqminx+0x498>
nopw   0x0(%rax,%rax,1)
mov    (%r12,%rdx,8),%rax
mov    0x10(%rsp),%rsi
mov    (%rsi,%rdx,8),%rsi
movss  (%rsi,%rdx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    0x30(%rsp),%r14
movss  (%r14),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
mov    (%r9,%rdx,8),%rsi
movss  %xmm1,(%rax,%rdx,4)
mov    0x60(%rsp),%rax
movss  (%rax,%rdx,4),%xmm1
movss  %xmm1,0x4(%rsi)
add    $0x1,%rcx
cmp    %r11,%rcx
je     16c8 <mrqminx+0x558>
cmpl   $0x0,(%rbx,%rcx,4)
je     15fb <mrqminx+0x48b>
add    $0x1,%r8d
movslq %r8d,%rdx
xor    %esi,%esi
mov    $0x1,%r14d
cmp    $0x2,%r11d
jne    1672 <mrqminx+0x502>
test   $0x1,%r10b
je     15b0 <mrqminx+0x440>
cmpl   $0x0,(%rbx,%r14,4)
je     15b0 <mrqminx+0x440>
mov    0x10(%rsp),%rax
mov    (%rax,%rdx,8),%rax
movslq %esi,%rsi
movss  0x4(%rax,%rsi,4),%xmm1
mov    (%r12,%rdx,8),%rax
movss  %xmm1,0x4(%rax,%rsi,4)
jmp    15b0 <mrqminx+0x440>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rdi,%r14,1),%rax
add    $0x2,%rax
add    $0x2,%r14
cmp    $0x1,%rax
je     1623 <mrqminx+0x4b3>
cmpl   $0x0,(%rbx,%r14,4)
je     169a <mrqminx+0x52a>
mov    0x10(%rsp),%rax
mov    (%rax,%rdx,8),%r13
movslq %esi,%r15
add    $0x1,%esi
movss  0x4(%r13,%r15,4),%xmm1
mov    (%r12,%rdx,8),%rax
movss  %xmm1,0x4(%rax,%r15,4)
cmpl   $0x0,0x4(%rbx,%r14,4)
je     1660 <mrqminx+0x4f0>
mov    0x10(%rsp),%rax
mov    (%rax,%rdx,8),%rax
movslq %esi,%rbp
add    $0x1,%esi
movss  0x4(%rax,%rbp,4),%xmm1
mov    (%r12,%rdx,8),%rax
movss  %xmm1,0x4(%rax,%rbp,4)
jmp    1660 <mrqminx+0x4f0>
movb   $0x1,0xf(%rsp)
mov    0x2992(%rip),%esi
mov    0x29ab(%rip),%rdx
mov    %r12,%rdi
mov    $0x1,%ecx
call   1040 <gaussj@plt>
mov    0x2978(%rip),%ecx
test   %ecx,%ecx
mov    0x28(%rsp),%r10
jle    1797 <mrqminx+0x627>
mov    0x2984(%rip),%rdx
mov    0x2975(%rip),%rsi
lea    -0x1(%rcx),%rax
mov    %ecx,%r8d
and    $0x3,%r8d
mov    $0x1,%edi
cmp    $0x3,%rax
jb     176d <mrqminx+0x5fd>
mov    %ecx,%eax
and    $0xfffffffc,%eax
xor    %edi,%edi
mov    0x8(%rdx,%rdi,8),%rbp
movss  0x4(%rbp),%xmm0
movss  %xmm0,0x4(%rsi,%rdi,4)
mov    0x10(%rdx,%rdi,8),%rbp
movss  0x4(%rbp),%xmm0
movss  %xmm0,0x8(%rsi,%rdi,4)
mov    0x18(%rdx,%rdi,8),%rbp
movss  0x4(%rbp),%xmm0
movss  %xmm0,0xc(%rsi,%rdi,4)
mov    0x20(%rdx,%rdi,8),%rbp
movss  0x4(%rbp),%xmm0
movss  %xmm0,0x10(%rsi,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%rax
jne    1720 <mrqminx+0x5b0>
add    $0x1,%rdi
test   %r8,%r8
je     1797 <mrqminx+0x627>
lea    (%rsi,%rdi,4),%rax
lea    (%rdx,%rdi,8),%rdx
xor    %esi,%esi
nopl   0x0(%rax)
mov    (%rdx,%rsi,8),%rdi
movss  0x4(%rdi),%xmm0
movss  %xmm0,(%rax,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%r8
jne    1780 <mrqminx+0x610>
movss  (%r14),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1820 <mrqminx+0x6b0>
jp     1820 <mrqminx+0x6b0>
mov    %r12,%rdi
mov    %r10d,%esi
mov    %rbx,%rdx
mov    %r10,%rbx
call   1050 <covsrt@plt>
mov    0x28c2(%rip),%rdi
mov    0x289c(%rip),%edx
mov    $0x1,%esi
mov    $0x1,%ecx
mov    $0x1,%r8d
call   1060 <free_fmatrix@plt>
mov    0x2898(%rip),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   1030 <free_fvector@plt>
mov    0x287d(%rip),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   1030 <free_fvector@plt>
mov    0x2862(%rip),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free_fvector@plt>
cmpb   $0x0,0xf(%rsp)
je     1837 <mrqminx+0x6c7>
mov    0x283a(%rip),%r9
mov    0x2843(%rip),%rax
jmp    1882 <mrqminx+0x712>
mov    0x283a(%rip),%rax
mov    0x2823(%rip),%r9
lea    0x1(%r10),%edx
lea    -0x1(%rdx),%r8
cmp    $0x2,%edx
jne    1a30 <mrqminx+0x8c0>
xor    %esi,%esi
mov    $0x1,%edx
mov    0x18(%rsp),%rcx
test   $0x1,%r8b
je     1882 <mrqminx+0x712>
cmpl   $0x0,(%rbx,%rdx,4)
je     1882 <mrqminx+0x712>
movss  (%rcx,%rdx,4),%xmm0
movslq %esi,%rcx
addss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,(%r9,%rdx,4)
mov    0x38(%rsp),%rdi
mov    0x20(%rsp),%esi
mov    0x48(%rsp),%rdx
mov    0x50(%rsp),%rcx
mov    0x24(%rsp),%r8d
push   0x40(%rsp)
mov    0x60(%rsp),%rbp
push   %rbp
push   %rax
push   %r12
push   %r10
push   %rbx
call   1080 <mrqcofx@plt>
mov    %rbp,%rax
add    $0x30,%rsp
movss  0x27a6(%rip),%xmm0
ucomiss 0x0(%rbp),%xmm0
movss  (%r14),%xmm1
jbe    1a10 <mrqminx+0x8a0>
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
mulsd  0x72c(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%r14)
movss  (%rax),%xmm0
movss  %xmm0,0x2773(%rip)
cmpb   $0x0,0xf(%rsp)
jne    1a21 <mrqminx+0x8b1>
mov    0x2775(%rip),%r8
mov    0x2766(%rip),%r9
mov    0x2757(%rip),%r10
mov    0x28(%rsp),%rax
add    $0x1,%eax
mov    %rax,%r13
lea    -0x1(%rax),%r11
mov    %r11,%rdi
and    $0xfffffffffffffffe,%rdi
neg    %rdi
xor    %r14d,%r14d
mov    $0x1,%r15d
jmp    196a <mrqminx+0x7fa>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%r8,%rdx,4),%xmm0
movss  %xmm0,(%r9,%rdx,4)
movss  (%r10,%r15,4),%xmm0
mov    0x18(%rsp),%rax
movss  %xmm0,(%rax,%r15,4)
add    $0x1,%r15
cmp    %r13,%r15
je     1a21 <mrqminx+0x8b1>
cmpl   $0x0,(%rbx,%r15,4)
je     195d <mrqminx+0x7ed>
add    $0x1,%r14d
movslq %r14d,%rdx
xor    %esi,%esi
mov    $0x1,%eax
cmp    $0x2,%r13d
jne    19c2 <mrqminx+0x852>
test   $0x1,%r11b
je     1940 <mrqminx+0x7d0>
cmpl   $0x0,(%rbx,%rax,4)
je     1940 <mrqminx+0x7d0>
mov    (%r12,%rdx,8),%rax
movslq %esi,%rcx
movss  0x4(%rax,%rcx,4),%xmm0
mov    0x10(%rsp),%rax
mov    (%rax,%rdx,8),%rax
movss  %xmm0,0x4(%rax,%rcx,4)
jmp    1940 <mrqminx+0x7d0>
nop
lea    (%rdi,%rax,1),%rcx
add    $0x2,%rcx
add    $0x2,%rax
cmp    $0x1,%rcx
je     1985 <mrqminx+0x815>
cmpl   $0x0,(%rbx,%rax,4)
je     19e8 <mrqminx+0x878>
mov    (%r12,%rdx,8),%rbp
movslq %esi,%rcx
add    $0x1,%esi
movss  0x4(%rbp,%rcx,4),%xmm0
mov    0x10(%rsp),%rbp
mov    0x0(%rbp,%rdx,8),%rbp
movss  %xmm0,0x4(%rbp,%rcx,4)
cmpl   $0x0,0x4(%rbx,%rax,4)
je     19b0 <mrqminx+0x840>
mov    (%r12,%rdx,8),%rcx
movslq %esi,%rbp
add    $0x1,%esi
movss  0x4(%rcx,%rbp,4),%xmm0
mov    0x10(%rsp),%rcx
mov    (%rcx,%rdx,8),%rcx
movss  %xmm0,0x4(%rcx,%rbp,4)
jmp    19b0 <mrqminx+0x840>
mulss  0x5f8(%rip),%xmm1
movss  %xmm1,(%r14)
movss  %xmm0,(%rax)
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r8,%rdi
and    $0xfffffffffffffffe,%rdi
neg    %rdi
xor    %esi,%esi
mov    $0x1,%edx
mov    0x18(%rsp),%rcx
jmp    1a66 <mrqminx+0x8f6>
nopl   0x0(%rax,%rax,1)
lea    (%rdi,%rdx,1),%rbp
add    $0x2,%rbp
add    $0x2,%rdx
cmp    $0x1,%rbp
je     1862 <mrqminx+0x6f2>
cmpl   $0x0,(%rbx,%rdx,4)
je     1a83 <mrqminx+0x913>
movss  (%rcx,%rdx,4),%xmm0
movslq %esi,%rbp
add    $0x1,%esi
addss  0x4(%rax,%rbp,4),%xmm0
movss  %xmm0,(%r9,%rdx,4)
cmpl   $0x0,0x4(%rbx,%rdx,4)
je     1a50 <mrqminx+0x8e0>
movss  0x4(%rcx,%rdx,4),%xmm0
movslq %esi,%rbp
add    $0x1,%esi
addss  0x4(%rax,%rbp,4),%xmm0
movss  %xmm0,0x4(%r9,%rdx,4)
jmp    1a50 <mrqminx+0x8e0>

LLVM IR (-O0):
@mrqminx.mfit = internal global i32 0
@mrqminx.ochisq = internal global float 0.000000e+00
@mrqminx.atry = internal global float* null
@mrqminx.beta = internal global float* null
@mrqminx.da = internal global float* null
@mrqminx.oneda = internal global float** null
define void @mrqminx(float* %0, i32 %1, float* %2, float* %3, i32 %4, float* %5, i32* %6, i32 %7, float** %8, float** %9, float* %10, void (float*, float*, float*, float*, i32)* %11, float* %12) {
%14 = alloca float*
%15 = alloca i32
%16 = alloca float*
%17 = alloca float*
%18 = alloca i32
%19 = alloca float*
%20 = alloca i32*
%21 = alloca i32
%22 = alloca float**
%23 = alloca float**
%24 = alloca float*
%25 = alloca void (float*, float*, float*, float*, i32)*
%26 = alloca float*
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
store float* %0, float** %14
store i32 %1, i32* %15
store float* %2, float** %16
store float* %3, float** %17
store i32 %4, i32* %18
store float* %5, float** %19
store i32* %6, i32** %20
store i32 %7, i32* %21
store float** %8, float*** %22
store float** %9, float*** %23
store float* %10, float** %24
store void (float*, float*, float*, float*, i32)* %11, void (float*, float*, float*, float*, i32)** %25
store float* %12, float** %26
%31 = load float*, float** %26
%32 = load float, float* %31
%33 = fpext float %32 to double
%34 = fcmp olt double %33, 0.000000e+00
br i1 %34, label %35, label %97
35: ; preds = %13
%36 = load i32, i32* %21
%37 = call float* @fvector(i32 1, i32 %36)
store float* %37, float** @mrqminx.atry
%38 = load i32, i32* %21
%39 = call float* @fvector(i32 1, i32 %38)
store float* %39, float** @mrqminx.beta
%40 = load i32, i32* %21
%41 = call float* @fvector(i32 1, i32 %40)
store float* %41, float** @mrqminx.da
store i32 0, i32* @mrqminx.mfit
store i32 1, i32* %27
br label %42
42: ; preds = %57, %35
%43 = load i32, i32* %27
%44 = load i32, i32* %21
%45 = icmp sle i32 %43, %44
br i1 %45, label %46, label %60
46: ; preds = %42
%47 = load i32*, i32** %20
%48 = load i32, i32* %27
%49 = sext i32 %48 to i64
%50 = getelementptr inbounds i32, i32* %47, i64 %49
%51 = load i32, i32* %50
%52 = icmp ne i32 %51, 0
br i1 %52, label %53, label %56
53: ; preds = %46
%54 = load i32, i32* @mrqminx.mfit
%55 = add nsw i32 %54, 1
store i32 %55, i32* @mrqminx.mfit
br label %56
56: ; preds = %53, %46
br label %57
57: ; preds = %56
%58 = load i32, i32* %27
%59 = add nsw i32 %58, 1
store i32 %59, i32* %27
br label %42
60: ; preds = %42
%61 = load i32, i32* @mrqminx.mfit
%62 = call float** @fmatrix(i32 1, i32 %61, i32 1, i32 1)
store float** %62, float*** @mrqminx.oneda
%63 = load float*, float** %26
store float 0x3F50624DE0000000, float* %63
%64 = load float*, float** %14
%65 = load i32, i32* %15
%66 = load float*, float** %16
%67 = load float*, float** %17
%68 = load i32, i32* %18
%69 = load float*, float** %19
%70 = load i32*, i32** %20
%71 = load i32, i32* %21
%72 = load float**, float*** %23
%73 = load float*, float** @mrqminx.beta
%74 = load float*, float** %24
%75 = load void (float*, float*, float*, float*, i32)*, void (float*, float*, float*, float*, i32)** %25
%76 = call i32 @mrqcofx(float* %64, i32 %65, float* %66, float* %67, i32 %68, float* %69, i32* %70, i32 %71, float** %72, float* %73, float* %74, void (float*, float*, float*, float*, i32)* %75)
%77 = load float*, float** %24
%78 = load float, float* %77
store float %78, float* @mrqminx.ochisq
store i32 1, i32* %27
br label %79
79: ; preds = %93, %60
%80 = load i32, i32* %27
%81 = load i32, i32* %21
%82 = icmp sle i32 %80, %81
br i1 %82, label %83, label %96
83: ; preds = %79
%84 = load float*, float** %19
%85 = load i32, i32* %27
%86 = sext i32 %85 to i64
%87 = getelementptr inbounds float, float* %84, i64 %86
%88 = load float, float* %87
%89 = load float*, float** @mrqminx.atry
%90 = load i32, i32* %27
%91 = sext i32 %90 to i64
%92 = getelementptr inbounds float, float* %89, i64 %91
store float %88, float* %92
br label %93
93: ; preds = %83
%94 = load i32, i32* %27
%95 = add nsw i32 %94, 1
store i32 %95, i32* %27
br label %79
96: ; preds = %79
br label %97
97: ; preds = %96, %13
store i32 0, i32* %27
store i32 1, i32* %29
br label %98
98: ; preds = %184, %97
%99 = load i32, i32* %29
%100 = load i32, i32* %21
%101 = icmp sle i32 %99, %100
br i1 %101, label %102, label %187
102: ; preds = %98
%103 = load i32*, i32** %20
%104 = load i32, i32* %29
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds i32, i32* %103, i64 %105
%107 = load i32, i32* %106
%108 = icmp ne i32 %107, 0
br i1 %108, label %109, label %183
109: ; preds = %102
%110 = load i32, i32* %27
%111 = add nsw i32 %110, 1
store i32 %111, i32* %27
store i32 0, i32* %28
store i32 1, i32* %30
br label %112
112: ; preds = %144, %109
%113 = load i32, i32* %30
%114 = load i32, i32* %21
%115 = icmp sle i32 %113, %114
br i1 %115, label %116, label %147
116: ; preds = %112
%117 = load i32*, i32** %20
%118 = load i32, i32* %30
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds i32, i32* %117, i64 %119
%121 = load i32, i32* %120
%122 = icmp ne i32 %121, 0
br i1 %122, label %123, label %143
123: ; preds = %116
%124 = load i32, i32* %28
%125 = add nsw i32 %124, 1
store i32 %125, i32* %28
%126 = load float**, float*** %23
%127 = load i32, i32* %27
%128 = sext i32 %127 to i64
%129 = getelementptr inbounds float*, float** %126, i64 %128
%130 = load float*, float** %129
%131 = load i32, i32* %28
%132 = sext i32 %131 to i64
%133 = getelementptr inbounds float, float* %130, i64 %132
%134 = load float, float* %133
%135 = load float**, float*** %22
%136 = load i32, i32* %27
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds float*, float** %135, i64 %137
%139 = load float*, float** %138
%140 = load i32, i32* %28
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds float, float* %139, i64 %141
store float %134, float* %142
br label %143
143: ; preds = %123, %116
br label %144
144: ; preds = %143
%145 = load i32, i32* %30
%146 = add nsw i32 %145, 1
store i32 %146, i32* %30
br label %112
147: ; preds = %112
%148 = load float**, float*** %23
%149 = load i32, i32* %27
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds float*, float** %148, i64 %150
%152 = load float*, float** %151
%153 = load i32, i32* %27
%154 = sext i32 %153 to i64
%155 = getelementptr inbounds float, float* %152, i64 %154
%156 = load float, float* %155
%157 = fpext float %156 to double
%158 = load float*, float** %26
%159 = load float, float* %158
%160 = fpext float %159 to double
%161 = fadd double 1.000000e+00, %160
%162 = fmul double %157, %161
%163 = fptrunc double %162 to float
%164 = load float**, float*** %22
%165 = load i32, i32* %27
%166 = sext i32 %165 to i64
%167 = getelementptr inbounds float*, float** %164, i64 %166
%168 = load float*, float** %167
%169 = load i32, i32* %27
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds float, float* %168, i64 %170
store float %163, float* %171
%172 = load float*, float** @mrqminx.beta
%173 = load i32, i32* %27
%174 = sext i32 %173 to i64
%175 = getelementptr inbounds float, float* %172, i64 %174
%176 = load float, float* %175
%177 = load float**, float*** @mrqminx.oneda
%178 = load i32, i32* %27
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds float*, float** %177, i64 %179
%181 = load float*, float** %180
%182 = getelementptr inbounds float, float* %181, i64 1
store float %176, float* %182
br label %183
183: ; preds = %147, %102
br label %184
184: ; preds = %183
%185 = load i32, i32* %29
%186 = add nsw i32 %185, 1
store i32 %186, i32* %29
br label %98
187: ; preds = %98
%188 = load float**, float*** %22
%189 = load i32, i32* @mrqminx.mfit
%190 = load float**, float*** @mrqminx.oneda
%191 = call i32 @gaussj(float** %188, i32 %189, float** %190, i32 1)
store i32 1, i32* %27
br label %192
192: ; preds = %208, %187
%193 = load i32, i32* %27
%194 = load i32, i32* @mrqminx.mfit
%195 = icmp sle i32 %193, %194
br i1 %195, label %196, label %211
196: ; preds = %192
%197 = load float**, float*** @mrqminx.oneda
%198 = load i32, i32* %27
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds float*, float** %197, i64 %199
%201 = load float*, float** %200
%202 = getelementptr inbounds float, float* %201, i64 1
%203 = load float, float* %202
%204 = load float*, float** @mrqminx.da
%205 = load i32, i32* %27
%206 = sext i32 %205 to i64
%207 = getelementptr inbounds float, float* %204, i64 %206
store float %203, float* %207
br label %208
208: ; preds = %196
%209 = load i32, i32* %27
%210 = add nsw i32 %209, 1
store i32 %210, i32* %27
br label %192
211: ; preds = %192
%212 = load float*, float** %26
%213 = load float, float* %212
%214 = fpext float %213 to double
%215 = fcmp oeq double %214, 0.000000e+00
br i1 %215, label %216, label %234
216: ; preds = %211
%217 = load float**, float*** %22
%218 = load i32, i32* %21
%219 = load i32*, i32** %20
%220 = load i32, i32* @mrqminx.mfit
%221 = call i32 @covsrt(float** %217, i32 %218, i32* %219, i32 %220)
%222 = load float**, float*** @mrqminx.oneda
%223 = load i32, i32* @mrqminx.mfit
%224 = call i32 @free_fmatrix(float** %222, i32 1, i32 %223, i32 1, i32 1)
%225 = load float*, float** @mrqminx.da
%226 = load i32, i32* %21
%227 = call i32 @free_fvector(float* %225, i32 1, i32 %226)
%228 = load float*, float** @mrqminx.beta
%229 = load i32, i32* %21
%230 = call i32 @free_fvector(float* %228, i32 1, i32 %229)
%231 = load float*, float** @mrqminx.atry
%232 = load i32, i32* %21
%233 = call i32 @free_fvector(float* %231, i32 1, i32 %232)
br label %374
234: ; preds = %211
store i32 0, i32* %27
store i32 1, i32* %29
br label %235
235: ; preds = %264, %234
%236 = load i32, i32* %29
%237 = load i32, i32* %21
%238 = icmp sle i32 %236, %237
br i1 %238, label %239, label %267
239: ; preds = %235
%240 = load i32*, i32** %20
%241 = load i32, i32* %29
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds i32, i32* %240, i64 %242
%244 = load i32, i32* %243
%245 = icmp ne i32 %244, 0
br i1 %245, label %246, label %263
246: ; preds = %239
%247 = load float*, float** %19
%248 = load i32, i32* %29
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds float, float* %247, i64 %249
%251 = load float, float* %250
%252 = load float*, float** @mrqminx.da
%253 = load i32, i32* %27
%254 = add nsw i32 %253, 1
store i32 %254, i32* %27
%255 = sext i32 %254 to i64
%256 = getelementptr inbounds float, float* %252, i64 %255
%257 = load float, float* %256
%258 = fadd float %251, %257
%259 = load float*, float** @mrqminx.atry
%260 = load i32, i32* %29
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds float, float* %259, i64 %261
store float %258, float* %262
br label %263
263: ; preds = %246, %239
br label %264
264: ; preds = %263
%265 = load i32, i32* %29
%266 = add nsw i32 %265, 1
store i32 %266, i32* %29
br label %235
267: ; preds = %235
%268 = load float*, float** %14
%269 = load i32, i32* %15
%270 = load float*, float** %16
%271 = load float*, float** %17
%272 = load i32, i32* %18
%273 = load float*, float** @mrqminx.atry
%274 = load i32*, i32** %20
%275 = load i32, i32* %21
%276 = load float**, float*** %22
%277 = load float*, float** @mrqminx.da
%278 = load float*, float** %24
%279 = load void (float*, float*, float*, float*, i32)*, void (float*, float*, float*, float*, i32)** %25
%280 = call i32 @mrqcofx(float* %268, i32 %269, float* %270, float* %271, i32 %272, float* %273, i32* %274, i32 %275, float** %276, float* %277, float* %278, void (float*, float*, float*, float*, i32)* %279)
%281 = load float*, float** %24
%282 = load float, float* %281
%283 = load float, float* @mrqminx.ochisq
%284 = fcmp olt float %282, %283
br i1 %284, label %285, label %366
285: ; preds = %267
%286 = load float*, float** %26
%287 = load float, float* %286
%288 = fpext float %287 to double
%289 = fmul double %288, 1.000000e-01
%290 = fptrunc double %289 to float
store float %290, float* %286
%291 = load float*, float** %24
%292 = load float, float* %291
store float %292, float* @mrqminx.ochisq
store i32 0, i32* %27
store i32 1, i32* %29
br label %293
293: ; preds = %362, %285
%294 = load i32, i32* %29
%295 = load i32, i32* %21
%296 = icmp sle i32 %294, %295
br i1 %296, label %297, label %365
297: ; preds = %293
%298 = load i32*, i32** %20
%299 = load i32, i32* %29
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds i32, i32* %298, i64 %300
%302 = load i32, i32* %301
%303 = icmp ne i32 %302, 0
br i1 %303, label %304, label %361
304: ; preds = %297
%305 = load i32, i32* %27
%306 = add nsw i32 %305, 1
store i32 %306, i32* %27
store i32 0, i32* %28
store i32 1, i32* %30
br label %307
307: ; preds = %339, %304
%308 = load i32, i32* %30
%309 = load i32, i32* %21
%310 = icmp sle i32 %308, %309
br i1 %310, label %311, label %342
311: ; preds = %307
%312 = load i32*, i32** %20
%313 = load i32, i32* %30
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds i32, i32* %312, i64 %314
%316 = load i32, i32* %315
%317 = icmp ne i32 %316, 0
br i1 %317, label %318, label %338
318: ; preds = %311
%319 = load i32, i32* %28
%320 = add nsw i32 %319, 1
store i32 %320, i32* %28
%321 = load float**, float*** %22
%322 = load i32, i32* %27
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds float*, float** %321, i64 %323
%325 = load float*, float** %324
%326 = load i32, i32* %28
%327 = sext i32 %326 to i64
%328 = getelementptr inbounds float, float* %325, i64 %327
%329 = load float, float* %328
%330 = load float**, float*** %23
%331 = load i32, i32* %27
%332 = sext i32 %331 to i64
%333 = getelementptr inbounds float*, float** %330, i64 %332
%334 = load float*, float** %333
%335 = load i32, i32* %28
%336 = sext i32 %335 to i64
%337 = getelementptr inbounds float, float* %334, i64 %336
store float %329, float* %337
br label %338
338: ; preds = %318, %311
br label %339
339: ; preds = %338
%340 = load i32, i32* %30
%341 = add nsw i32 %340, 1
store i32 %341, i32* %30
br label %307
342: ; preds = %307
%343 = load float*, float** @mrqminx.da
%344 = load i32, i32* %27
%345 = sext i32 %344 to i64
%346 = getelementptr inbounds float, float* %343, i64 %345
%347 = load float, float* %346
%348 = load float*, float** @mrqminx.beta
%349 = load i32, i32* %27
%350 = sext i32 %349 to i64
%351 = getelementptr inbounds float, float* %348, i64 %350
store float %347, float* %351
%352 = load float*, float** @mrqminx.atry
%353 = load i32, i32* %29
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds float, float* %352, i64 %354
%356 = load float, float* %355
%357 = load float*, float** %19
%358 = load i32, i32* %29
%359 = sext i32 %358 to i64
%360 = getelementptr inbounds float, float* %357, i64 %359
store float %356, float* %360
br label %361
361: ; preds = %342, %297
br label %362
362: ; preds = %361
%363 = load i32, i32* %29
%364 = add nsw i32 %363, 1
store i32 %364, i32* %29
br label %293
365: ; preds = %293
br label %374
366: ; preds = %267
%367 = load float*, float** %26
%368 = load float, float* %367
%369 = fpext float %368 to double
%370 = fmul double %369, 1.000000e+01
%371 = fptrunc double %370 to float
store float %371, float* %367
%372 = load float, float* @mrqminx.ochisq
%373 = load float*, float** %24
store float %372, float* %373
br label %374
374: ; preds = %216, %366, %365
ret void
}

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