#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*/ mrqcof(float *, float *, float *, int, float *, int *, int,
                          float **, float *, float *,
                          void (*)(float, float *, float *, float *, int));
void mrqmin(float x[], 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;
    mrqcof(x, 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];
  mrqcof(x, 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):
<mrqmin>:
push   %rbp
mov    %rsp,%rbp
push   %r14
push   %rbx
sub    $0x70,%rsp
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%eax
mov    %rdi,-0x18(%rbp)
mov    %rsi,-0x20(%rbp)
mov    %rdx,-0x28(%rbp)
mov    %ecx,-0x2c(%rbp)
mov    %r8,-0x38(%rbp)
mov    %r9,-0x40(%rbp)
mov    0x38(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1318 <mrqmin+0x1a8>
mov    0x10(%rbp),%esi
mov    $0x1,%edi
call   1070 <fvector@plt>
mov    %rax,0x2e92(%rip)
mov    0x10(%rbp),%esi
mov    $0x1,%edi
call   1070 <fvector@plt>
mov    %rax,0x2e86(%rip)
mov    0x10(%rbp),%esi
mov    $0x1,%edi
call   1070 <fvector@plt>
mov    %rax,0x2e7a(%rip)
movl   $0x0,0x2e58(%rip)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     124f <mrqmin+0xdf>
mov    -0x40(%rbp),%rax
movslq -0x44(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     123c <mrqmin+0xcc>
mov    0x2e2d(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2e24(%rip)
jmp    1241 <mrqmin+0xd1>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    120f <mrqmin+0x9f>
mov    0x2e0b(%rip),%esi
mov    $0x1,%ecx
mov    %ecx,%edi
mov    %ecx,%edx
call   1090 <fmatrix@plt>
mov    %rax,0x2e16(%rip)
mov    0x38(%rbp),%rax
movss  0xd8a(%rip),%xmm0
movss  %xmm0,(%rax)
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x2c(%rbp),%ecx
mov    -0x38(%rbp),%r8
mov    -0x40(%rbp),%r9
mov    0x10(%rbp),%r14d
mov    0x20(%rbp),%rbx
mov    0x2dd0(%rip),%r11
mov    0x28(%rbp),%r10
mov    0x30(%rbp),%rax
mov    %r14d,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
call   1080 <mrqcof@plt>
mov    0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,0x2d8f(%rip)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     1313 <mrqmin+0x1a3>
mov    -0x38(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x2d6c(%rip),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12dc <mrqmin+0x16c>
jmp    1318 <mrqmin+0x1a8>
movl   $0x0,-0x44(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     1444 <mrqmin+0x2d4>
mov    -0x40(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1431 <mrqmin+0x2c1>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     13bf <mrqmin+0x24f>
mov    -0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     13ac <mrqmin+0x23c>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    13b1 <mrqmin+0x241>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    135b <mrqmin+0x1eb>
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x38(%rbp),%rax
movss  (%rax),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xc2c(%rip),%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x2c5c(%rip),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x2c5c(%rip),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x4(%rax)
jmp    1436 <mrqmin+0x2c6>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1326 <mrqmin+0x1b6>
mov    0x18(%rbp),%rdi
mov    0x2c12(%rip),%esi
mov    0x2c2b(%rip),%rdx
mov    $0x1,%ecx
call   1040 <gaussj@plt>
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x2bf1(%rip),%eax
jg     14a7 <mrqmin+0x337>
mov    0x2c04(%rip),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x4(%rax),%xmm0
mov    0x2be8(%rip),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1466 <mrqmin+0x2f6>
mov    0x38(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    153b <mrqmin+0x3cb>
jp     153b <mrqmin+0x3cb>
mov    0x18(%rbp),%rdi
mov    0x10(%rbp),%esi
mov    -0x40(%rbp),%rdx
mov    0x2b89(%rip),%ecx
call   1050 <covsrt@plt>
mov    0x2b9d(%rip),%rdi
mov    0x2b77(%rip),%edx
mov    $0x1,%r8d
mov    %r8d,%esi
mov    %r8d,%ecx
call   1060 <free_fmatrix@plt>
mov    0x2b77(%rip),%rdi
mov    0x10(%rbp),%edx
mov    $0x1,%esi
call   1030 <free_fvector@plt>
mov    0x2b5b(%rip),%rdi
mov    0x10(%rbp),%edx
mov    $0x1,%esi
call   1030 <free_fvector@plt>
mov    0x2b3f(%rip),%rdi
mov    0x10(%rbp),%edx
mov    $0x1,%esi
call   1030 <free_fvector@plt>
jmp    1772 <mrqmin+0x602>
movl   $0x0,-0x44(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     15af <mrqmin+0x43f>
mov    -0x40(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     159c <mrqmin+0x42c>
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x2afd(%rip),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x44(%rbp)
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x2ad5(%rip),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    15a1 <mrqmin+0x431>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1549 <mrqmin+0x3d9>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x2c(%rbp),%ecx
mov    0x2aa3(%rip),%r8
mov    -0x40(%rbp),%r9
mov    0x10(%rbp),%r14d
mov    0x18(%rbp),%rbx
mov    0x2aa0(%rip),%r11
mov    0x28(%rbp),%r10
mov    0x30(%rbp),%rax
mov    %r14d,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %rax,0x20(%rsp)
call   1080 <mrqcof@plt>
mov    0x28(%rbp),%rax
movss  (%rax),%xmm1
movss  0x2a57(%rip),%xmm0
ucomiss %xmm1,%xmm0
jbe    1742 <mrqmin+0x5d2>
mov    0x38(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x9e6(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,0x2a1e(%rip)
movl   $0x0,-0x44(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     173d <mrqmin+0x5cd>
mov    -0x40(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     172a <mrqmin+0x5ba>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
movl   $0x0,-0x48(%rbp)
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     16ed <mrqmin+0x57d>
mov    -0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     16da <mrqmin+0x56a>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    0x18(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    16df <mrqmin+0x56f>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1689 <mrqmin+0x519>
mov    0x2984(%rip),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x296c(%rip),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x2954(%rip),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    172f <mrqmin+0x5bf>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1654 <mrqmin+0x4e4>
jmp    1772 <mrqmin+0x602>
mov    0x38(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x8b2(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax)
movss  0x28fa(%rip),%xmm0
mov    0x28(%rbp),%rax
movss  %xmm0,(%rax)
add    $0x70,%rsp
pop    %rbx
pop    %r14
pop    %rbp
ret

x86 assembly (clang, -O2):
<mrqmin>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x68,%rsp
mov    %r9,%r13
mov    %r8,0x18(%rsp)
mov    %ecx,0x24(%rsp)
mov    %rdx,0x50(%rsp)
mov    %rsi,0x40(%rsp)
mov    %rdi,0x38(%rsp)
mov    0xc8(%rsp),%rcx
mov    0xc0(%rsp),%rax
mov    %rax,0x48(%rsp)
mov    0xb8(%rsp),%rax
mov    %rax,0x58(%rsp)
mov    0xb0(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    0xa8(%rsp),%r12
mov    0xa0(%rsp),%esi
xorps  %xmm0,%xmm0
mov    %rcx,0x30(%rsp)
ucomiss (%rcx),%xmm0
mov    %rsi,0x28(%rsp)
jbe    1537 <mrqmin+0x3c7>
mov    $0x1,%edi
call   1070 <fvector@plt>
mov    %rax,0x2e6a(%rip)
mov    $0x1,%edi
mov    0x28(%rsp),%rsi
call   1070 <fvector@plt>
mov    %rax,0x2e5c(%rip)
mov    $0x1,%edi
mov    0x28(%rsp),%rsi
call   1070 <fvector@plt>
mov    0x28(%rsp),%rbp
mov    %rax,0x2e49(%rip)
movl   $0x0,0x2e27(%rip)
test   %ebp,%ebp
jle    1313 <mrqmin+0x1a3>
mov    %ebp,%r14d
cmp    $0x1,%ebp
jne    1389 <mrqmin+0x219>
xor    %esi,%esi
mov    $0x1,%eax
test   $0x1,%r14b
je     126b <mrqmin+0xfb>
cmpl   $0x0,0x0(%r13,%rax,4)
je     126b <mrqmin+0xfb>
add    $0x1,%esi
mov    %esi,0x2df5(%rip)
mov    $0x1,%edi
mov    $0x1,%edx
mov    $0x1,%ecx
call   1090 <fmatrix@plt>
mov    %rax,0x2dfa(%rip)
mov    0x30(%rsp),%rax
movl   $0x3a83126f,(%rax)
sub    $0x8,%rsp
mov    0x40(%rsp),%rdi
mov    0x48(%rsp),%rsi
mov    0x58(%rsp),%rdx
mov    0x2c(%rsp),%ecx
mov    0x20(%rsp),%r8
mov    %r13,%r9
push   0x50(%rsp)
mov    0x68(%rsp),%rbp
push   %rbp
push   0x2db0(%rip)
push   0x30(%rsp)
mov    0x50(%rsp),%rbx
push   %rbx
call   1080 <mrqcof@plt>
mov    %rbx,%rsi
add    $0x30,%rsp
movss  0x0(%rbp),%xmm0
movss  %xmm0,0x2d81(%rip)
test   %esi,%esi
jle    1694 <mrqmin+0x524>
add    $0x1,%r14
mov    0x2d72(%rip),%rax
lea    -0x1(%r14),%r8
mov    $0x1,%ecx
cmp    $0x8,%r8
jae    13da <mrqmin+0x26a>
mov    0x18(%rsp),%rdx
jmp    14c1 <mrqmin+0x351>
mov    $0x1,%edi
xor    %esi,%esi
mov    $0x1,%edx
mov    $0x1,%ecx
call   1090 <fmatrix@plt>
mov    %rax,0x2d50(%rip)
mov    0x30(%rsp),%rax
movl   $0x3a83126f,(%rax)
sub    $0x8,%rsp
mov    0x40(%rsp),%rdi
mov    0x48(%rsp),%rsi
mov    0x58(%rsp),%rdx
mov    0x2c(%rsp),%ecx
mov    0x20(%rsp),%r8
mov    %r13,%r9
push   0x50(%rsp)
mov    0x68(%rsp),%rbx
push   %rbx
push   0x2d06(%rip)
push   0x30(%rsp)
push   %rbp
call   1080 <mrqcof@plt>
add    $0x30,%rsp
movss  (%rbx),%xmm0
movss  %xmm0,0x2ce0(%rip)
jmp    1694 <mrqmin+0x524>
mov    %r14d,%ecx
and    $0xfffffffe,%ecx
neg    %rcx
xor    %esi,%esi
mov    $0x1,%eax
jmp    13b6 <mrqmin+0x246>
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
je     1254 <mrqmin+0xe4>
cmpl   $0x0,0x0(%r13,%rax,4)
je     13c7 <mrqmin+0x257>
add    $0x1,%esi
mov    %esi,0x2c99(%rip)
cmpl   $0x0,0x4(%r13,%rax,4)
je     13a0 <mrqmin+0x230>
add    $0x1,%esi
mov    %esi,0x2c88(%rip)
jmp    13a0 <mrqmin+0x230>
lea    0x4(%rax),%rbp
mov    0x18(%rsp),%rdx
lea    (%rdx,%r14,4),%rdi
cmp    %rdi,%rbp
jae    13fd <mrqmin+0x28d>
lea    (%rax,%r14,4),%rbp
lea    0x4(%rdx),%rdi
cmp    %rbp,%rdi
jb     14c1 <mrqmin+0x351>
mov    %r8,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rbp
shr    $0x3,%rbp
add    $0x1,%rbp
mov    %ebp,%ebx
and    $0x3,%ebx
cmp    $0x18,%rdi
jae    1422 <mrqmin+0x2b2>
xor    %edi,%edi
jmp    148a <mrqmin+0x31a>
and    $0xfffffffffffffffc,%rbp
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movups 0x4(%rdx,%rdi,4),%xmm0
movups 0x14(%rdx,%rdi,4),%xmm1
movups %xmm0,0x4(%rax,%rdi,4)
movups %xmm1,0x14(%rax,%rdi,4)
movups 0x24(%rdx,%rdi,4),%xmm0
movups 0x34(%rdx,%rdi,4),%xmm1
movups %xmm0,0x24(%rax,%rdi,4)
movups %xmm1,0x34(%rax,%rdi,4)
movups 0x44(%rdx,%rdi,4),%xmm0
movups 0x54(%rdx,%rdi,4),%xmm1
movups %xmm0,0x44(%rax,%rdi,4)
movups %xmm1,0x54(%rax,%rdi,4)
movups 0x64(%rdx,%rdi,4),%xmm0
movups 0x74(%rdx,%rdi,4),%xmm1
movups %xmm0,0x64(%rax,%rdi,4)
movups %xmm1,0x74(%rax,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rbp
jne    1430 <mrqmin+0x2c0>
test   %rbx,%rbx
je     14b8 <mrqmin+0x348>
nop
lea    0x0(,%rdi,4),%rbp
or     $0x4,%rbp
movups (%rdx,%rbp,1),%xmm0
movups 0x10(%rdx,%rbp,1),%xmm1
movups %xmm0,(%rax,%rbp,1)
movups %xmm1,0x10(%rax,%rbp,1)
add    $0x8,%rdi
add    $0xffffffffffffffff,%rbx
jne    1490 <mrqmin+0x320>
cmp    %rcx,%r8
je     1537 <mrqmin+0x3c7>
or     $0x1,%rcx
mov    %r14d,%edi
sub    %ecx,%edi
mov    %rcx,%rbp
not    %rbp
add    %r14,%rbp
and    $0x3,%rdi
je     14f4 <mrqmin+0x384>
cs nopw 0x0(%rax,%rax,1)
nop
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rdi
jne    14e0 <mrqmin+0x370>
cmp    $0x3,%rbp
jb     1537 <mrqmin+0x3c7>
nopw   0x0(%rax,%rax,1)
movss  (%rdx,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  0x4(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rax,%rcx,4)
movss  0x8(%rdx,%rcx,4),%xmm0
movss  %xmm0,0x8(%rax,%rcx,4)
movss  0xc(%rdx,%rcx,4),%xmm0
movss  %xmm0,0xc(%rax,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r14
jne    1500 <mrqmin+0x390>
test   %esi,%esi
setle  0xf(%rsp)
jle    1694 <mrqmin+0x524>
mov    0x2b25(%rip),%rax
mov    %rax,0x60(%rsp)
mov    0x2b29(%rip),%r9
mov    %esi,%r10d
lea    0x1(%r10),%r11
mov    %r10d,%edi
and    $0xfffffffe,%edi
neg    %rdi
xor    %r8d,%r8d
mov    $0x1,%eax
movsd  0xa89(%rip),%xmm0
jmp    15d7 <mrqmin+0x467>
nopl   0x0(%rax)
mov    (%r12,%rcx,8),%rdx
mov    0x10(%rsp),%rsi
mov    (%rsi,%rcx,8),%rsi
movss  (%rsi,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    0x30(%rsp),%rsi
movss  (%rsi),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
mov    (%r9,%rcx,8),%rsi
movss  %xmm1,(%rdx,%rcx,4)
mov    0x60(%rsp),%rdx
movss  (%rdx,%rcx,4),%xmm1
movss  %xmm1,0x4(%rsi)
add    $0x1,%rax
cmp    %r11,%rax
je     1699 <mrqmin+0x529>
cmpl   $0x0,0x0(%r13,%rax,4)
je     15ca <mrqmin+0x45a>
add    $0x1,%r8d
movslq %r8d,%rcx
xor    %edx,%edx
mov    $0x1,%esi
cmp    $0x2,%r11d
jne    1642 <mrqmin+0x4d2>
test   $0x1,%r10b
je     1580 <mrqmin+0x410>
cmpl   $0x0,0x0(%r13,%rsi,4)
je     1580 <mrqmin+0x410>
mov    0x10(%rsp),%rsi
mov    (%rsi,%rcx,8),%rsi
movslq %edx,%rdx
movss  0x4(%rsi,%rdx,4),%xmm1
mov    (%r12,%rcx,8),%rsi
movss  %xmm1,0x4(%rsi,%rdx,4)
jmp    1580 <mrqmin+0x410>
cs nopw 0x0(%rax,%rax,1)
lea    (%rdi,%rsi,1),%rbx
add    $0x2,%rbx
add    $0x2,%rsi
cmp    $0x1,%rbx
je     15f3 <mrqmin+0x483>
cmpl   $0x0,0x0(%r13,%rsi,4)
je     166b <mrqmin+0x4fb>
mov    0x10(%rsp),%rbx
mov    (%rbx,%rcx,8),%r14
movslq %edx,%r15
add    $0x1,%edx
movss  0x4(%r14,%r15,4),%xmm1
mov    (%r12,%rcx,8),%rbp
movss  %xmm1,0x4(%rbp,%r15,4)
cmpl   $0x0,0x4(%r13,%rsi,4)
je     1630 <mrqmin+0x4c0>
mov    0x10(%rsp),%rbx
mov    (%rbx,%rcx,8),%rbp
movslq %edx,%rbx
add    $0x1,%edx
movss  0x4(%rbp,%rbx,4),%xmm1
mov    (%r12,%rcx,8),%rbp
movss  %xmm1,0x4(%rbp,%rbx,4)
jmp    1630 <mrqmin+0x4c0>
movb   $0x1,0xf(%rsp)
mov    0x29c1(%rip),%esi
mov    0x29da(%rip),%rdx
mov    %r12,%rdi
mov    $0x1,%ecx
call   1040 <gaussj@plt>
mov    0x29a7(%rip),%ecx
test   %ecx,%ecx
mov    0x28(%rsp),%r10
jle    1767 <mrqmin+0x5f7>
mov    0x29b3(%rip),%rdx
mov    0x29a4(%rip),%rsi
lea    -0x1(%rcx),%rbp
mov    %ecx,%eax
and    $0x3,%eax
mov    $0x1,%edi
cmp    $0x3,%rbp
jb     173d <mrqmin+0x5cd>
mov    %ecx,%ebp
and    $0xfffffffc,%ebp
xor    %edi,%edi
nop
mov    0x8(%rdx,%rdi,8),%rbx
movss  0x4(%rbx),%xmm0
movss  %xmm0,0x4(%rsi,%rdi,4)
mov    0x10(%rdx,%rdi,8),%rbx
movss  0x4(%rbx),%xmm0
movss  %xmm0,0x8(%rsi,%rdi,4)
mov    0x18(%rdx,%rdi,8),%rbx
movss  0x4(%rbx),%xmm0
movss  %xmm0,0xc(%rsi,%rdi,4)
mov    0x20(%rdx,%rdi,8),%rbx
movss  0x4(%rbx),%xmm0
movss  %xmm0,0x10(%rsi,%rdi,4)
add    $0x4,%rdi
cmp    %rdi,%rbp
jne    16f0 <mrqmin+0x580>
add    $0x1,%rdi
test   %rax,%rax
je     1767 <mrqmin+0x5f7>
lea    (%rsi,%rdi,4),%rsi
lea    (%rdx,%rdi,8),%rdx
xor    %edi,%edi
nopl   0x0(%rax)
mov    (%rdx,%rdi,8),%rbp
movss  0x4(%rbp),%xmm0
movss  %xmm0,(%rsi,%rdi,4)
add    $0x1,%rdi
cmp    %rdi,%rax
jne    1750 <mrqmin+0x5e0>
mov    0x30(%rsp),%rax
movss  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    17f4 <mrqmin+0x684>
jp     17f4 <mrqmin+0x684>
mov    %r12,%rdi
mov    %r10d,%esi
mov    %r13,%rdx
mov    %r10,%rbx
call   1050 <covsrt@plt>
mov    0x28ee(%rip),%rdi
mov    0x28c8(%rip),%edx
mov    $0x1,%esi
mov    $0x1,%ecx
mov    $0x1,%r8d
call   1060 <free_fmatrix@plt>
mov    0x28c4(%rip),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   1030 <free_fvector@plt>
mov    0x28a9(%rip),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
call   1030 <free_fvector@plt>
mov    0x288e(%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     180b <mrqmin+0x69b>
mov    0x2866(%rip),%r8
mov    0x286f(%rip),%rax
jmp    1857 <mrqmin+0x6e7>
mov    0x2866(%rip),%rax
mov    0x284f(%rip),%r8
lea    0x1(%r10),%edx
lea    -0x1(%rdx),%rcx
cmp    $0x2,%edx
jne    1a11 <mrqmin+0x8a1>
xor    %esi,%esi
mov    $0x1,%edx
mov    0x18(%rsp),%rbx
test   $0x1,%cl
je     1857 <mrqmin+0x6e7>
cmpl   $0x0,0x0(%r13,%rdx,4)
je     1857 <mrqmin+0x6e7>
movss  (%rbx,%rdx,4),%xmm0
movslq %esi,%rcx
addss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,(%r8,%rdx,4)
sub    $0x8,%rsp
mov    0x40(%rsp),%rdi
mov    0x48(%rsp),%rsi
mov    0x58(%rsp),%rdx
mov    0x2c(%rsp),%ecx
mov    %r13,%r9
push   0x50(%rsp)
mov    0x68(%rsp),%rbx
push   %rbx
push   %rax
push   %r12
push   %r10
call   1080 <mrqcof@plt>
mov    %rbx,%rax
add    $0x30,%rsp
movss  0x27d0(%rip),%xmm0
ucomiss (%rbx),%xmm0
mov    0x30(%rsp),%rcx
movss  (%rcx),%xmm1
jbe    19f2 <mrqmin+0x882>
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
mulsd  0x753(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rcx)
movss  (%rax),%xmm0
movss  %xmm0,0x279b(%rip)
cmpb   $0x0,0xf(%rsp)
jne    1a02 <mrqmin+0x892>
mov    0x279d(%rip),%r8
mov    0x278e(%rip),%r9
mov    0x277f(%rip),%r10
mov    0x28(%rsp),%rax
add    $0x1,%eax
mov    %rax,%r15
lea    -0x1(%rax),%r11
mov    %r11,%rdi
and    $0xfffffffffffffffe,%rdi
neg    %rdi
xor    %r14d,%r14d
mov    $0x1,%eax
jmp    1939 <mrqmin+0x7c9>
nopl   0x0(%rax)
movss  (%r8,%rcx,4),%xmm0
movss  %xmm0,(%r9,%rcx,4)
movss  (%r10,%rax,4),%xmm0
mov    0x18(%rsp),%rcx
movss  %xmm0,(%rcx,%rax,4)
add    $0x1,%rax
cmp    %r15,%rax
je     1a02 <mrqmin+0x892>
cmpl   $0x0,0x0(%r13,%rax,4)
je     192c <mrqmin+0x7bc>
add    $0x1,%r14d
movslq %r14d,%rcx
xor    %edx,%edx
mov    $0x1,%esi
cmp    $0x2,%r15d
jne    19a2 <mrqmin+0x832>
test   $0x1,%r11b
je     1910 <mrqmin+0x7a0>
cmpl   $0x0,0x0(%r13,%rsi,4)
je     1910 <mrqmin+0x7a0>
mov    (%r12,%rcx,8),%rsi
movslq %edx,%rdx
movss  0x4(%rsi,%rdx,4),%xmm0
mov    0x10(%rsp),%rsi
mov    (%rsi,%rcx,8),%rsi
movss  %xmm0,0x4(%rsi,%rdx,4)
jmp    1910 <mrqmin+0x7a0>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rdi,%rsi,1),%rbx
add    $0x2,%rbx
add    $0x2,%rsi
cmp    $0x1,%rbx
je     1955 <mrqmin+0x7e5>
cmpl   $0x0,0x0(%r13,%rsi,4)
je     19c9 <mrqmin+0x859>
mov    (%r12,%rcx,8),%rbx
movslq %edx,%rbp
add    $0x1,%edx
movss  0x4(%rbx,%rbp,4),%xmm0
mov    0x10(%rsp),%rbx
mov    (%rbx,%rcx,8),%rbx
movss  %xmm0,0x4(%rbx,%rbp,4)
cmpl   $0x0,0x4(%r13,%rsi,4)
je     1990 <mrqmin+0x820>
mov    (%r12,%rcx,8),%rbx
movslq %edx,%rbp
add    $0x1,%edx
movss  0x4(%rbx,%rbp,4),%xmm0
mov    0x10(%rsp),%rbx
mov    (%rbx,%rcx,8),%rbx
movss  %xmm0,0x4(%rbx,%rbp,4)
jmp    1990 <mrqmin+0x820>
mulss  0x616(%rip),%xmm1
movss  %xmm1,(%rcx)
movss  %xmm0,(%rax)
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %rcx,%rdi
and    $0xfffffffffffffffe,%rdi
neg    %rdi
xor    %esi,%esi
mov    $0x1,%edx
mov    0x18(%rsp),%rbx
jmp    1a46 <mrqmin+0x8d6>
nopl   0x0(%rax)
lea    (%rdi,%rdx,1),%rbp
add    $0x2,%rbp
add    $0x2,%rdx
cmp    $0x1,%rbp
je     1836 <mrqmin+0x6c6>
cmpl   $0x0,0x0(%r13,%rdx,4)
je     1a65 <mrqmin+0x8f5>
movss  (%rbx,%rdx,4),%xmm0
movslq %esi,%rbp
add    $0x1,%esi
addss  0x4(%rax,%rbp,4),%xmm0
movss  %xmm0,(%r8,%rdx,4)
cmpl   $0x0,0x4(%r13,%rdx,4)
je     1a30 <mrqmin+0x8c0>
movss  0x4(%rbx,%rdx,4),%xmm0
movslq %esi,%rbp
add    $0x1,%esi
addss  0x4(%rax,%rbp,4),%xmm0
movss  %xmm0,0x4(%r8,%rdx,4)
jmp    1a30 <mrqmin+0x8c0>

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

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