#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(double **, int, int *, int);
double **dmatrix(int, int, int, int);
double *dvector(int, int);
int /*<<< orphan*/ free_dmatrix(double **, int, int, int, int);
int /*<<< orphan*/ free_dvector(double *, int);
int gaussj(double **, int, double **, int);
int /*<<< orphan*/ mrqcof(float *, float *, float *, int, double *, int *, int,
                          double **, double *, double *,
                          void (*)(float, double *, double *, double *, int));
int mrqmin(float x[], float y[], float sig[], int ndata, double a[], int ma,
           int ia[], double **covar, double **alpha, double *chisq,
           void (*funcs)(float, double *, double *, double *, int),
           double *alamda, int **iconstr, double **constr) {
  int j, k, l, ier;
  static int mfit;
  static double ochisq, *atry, *beta, *da, **oneda;
  ier = 1;
  if (*alamda < 0.0) {
    atry = dvector(1, ma);
    beta = dvector(1, ma);
    da = dvector(1, ma);
    for (mfit = 0, j = 1; j <= ma; j++)
      if (ia[j])
        mfit++;
    oneda = dmatrix(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 = 1; j <= mfit; j++) {
    for (k = 1; k <= mfit; k++)
      covar[j][k] = alpha[j][k];
    covar[j][j] = alpha[j][j] * (1.0 + (*alamda));
    oneda[j][1] = beta[j];
  }
  ier = gaussj(covar, mfit, oneda, 1);
  if (ier == 0)
    goto out;
  for (j = 1; j <= mfit; j++)
    da[j] = oneda[j][1];
  if (*alamda == 0.0) {
    covsrt(covar, ma, ia, mfit);
  out:
    free_dmatrix(oneda, 1, mfit, 1, 1);
    free_dvector(da, 1);
    free_dvector(beta, 1);
    free_dvector(atry, 1);
    return ier;
  }
  for (j = 0, l = 1; l <= ma; l++)
    if (ia[l])
      atry[l] = a[l] + da[++j];
  if (iconstr && constr)
    for (j = 0, l = 1; l <= ma; l++) {
      if (iconstr[l][1])
        if (atry[l] < constr[l][1])
          atry[l] = constr[l][1];
      if (iconstr[l][2])
        if (atry[l] > constr[l][2])
          atry[l] = constr[l][2];
    }
  mrqcof(x, y, sig, ndata, atry, ia, ma, covar, da, chisq, funcs);
  if (*chisq < ochisq) {
    *alamda *= 0.1;
    ochisq = (*chisq);
    for (j = 1; j <= mfit; j++) {
      for (k = 1; k <= mfit; k++)
        alpha[j][k] = covar[j][k];
      beta[j] = da[j];
    }
    for (l = 1; l <= ma; l++)
      a[l] = atry[l];
  } else {
    *alamda *= 10.0;
    *chisq = ochisq;
  }
  return ier;
}


x86 assembly (clang, -O0):
<mrqmin>:
push   %rbp
mov    %rsp,%rbp
push   %r14
push   %rbx
sub    $0x70,%rsp
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x20(%rbp)
mov    %rsi,-0x28(%rbp)
mov    %rdx,-0x30(%rbp)
mov    %ecx,-0x34(%rbp)
mov    %r8,-0x40(%rbp)
mov    %r9d,-0x44(%rbp)
movl   $0x1,-0x54(%rbp)
mov    0x38(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    1320 <mrqmin+0x1b0>
mov    -0x44(%rbp),%esi
mov    $0x1,%edi
call   1070 <dvector@plt>
mov    %rax,0x2e92(%rip)
mov    -0x44(%rbp),%esi
mov    $0x1,%edi
call   1070 <dvector@plt>
mov    %rax,0x2e86(%rip)
mov    -0x44(%rbp),%esi
mov    $0x1,%edi
call   1070 <dvector@plt>
mov    %rax,0x2e7a(%rip)
movl   $0x0,0x2e50(%rip)
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     1257 <mrqmin+0xe7>
mov    0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1244 <mrqmin+0xd4>
mov    0x2e25(%rip),%eax
add    $0x1,%eax
mov    %eax,0x2e1c(%rip)
jmp    1249 <mrqmin+0xd9>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1217 <mrqmin+0xa7>
mov    0x2e03(%rip),%esi
mov    $0x1,%ecx
mov    %ecx,%edi
mov    %ecx,%edx
call   1050 <dmatrix@plt>
mov    %rax,0x2e16(%rip)
mov    0x38(%rbp),%rax
movsd  0xd82(%rip),%xmm0
movsd  %xmm0,(%rax)
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    -0x34(%rbp),%ecx
mov    -0x40(%rbp),%r8
mov    0x10(%rbp),%r9
mov    -0x44(%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   1060 <mrqcof@plt>
mov    0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0x2d8b(%rip)
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     131b <mrqmin+0x1ab>
mov    -0x40(%rbp),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2d6c(%rip),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    12e4 <mrqmin+0x174>
jmp    1320 <mrqmin+0x1b0>
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    0x2d30(%rip),%eax
jg     13f4 <mrqmin+0x284>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x2d1a(%rip),%eax
jg     1384 <mrqmin+0x214>
mov    0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    133d <mrqmin+0x1cd>
mov    0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x38(%rbp),%rax
movsd  0xc73(%rip),%xmm1
addsd  (%rax),%xmm1
mulsd  %xmm1,%xmm0
mov    0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    0x2caf(%rip),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2caf(%rip),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  %xmm0,0x8(%rax)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1327 <mrqmin+0x1b7>
mov    0x18(%rbp),%rdi
mov    0x2c62(%rip),%esi
mov    0x2c83(%rip),%rdx
mov    $0x1,%ecx
call   1030 <gaussj@plt>
mov    %eax,-0x54(%rbp)
cmpl   $0x0,-0x54(%rbp)
jne    1421 <mrqmin+0x2b1>
jmp    149a <mrqmin+0x32a>
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    0x2c2f(%rip),%eax
jg     1469 <mrqmin+0x2f9>
mov    0x2c4a(%rip),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
mov    0x2c2e(%rip),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1428 <mrqmin+0x2b8>
mov    0x38(%rbp),%rax
movsd  (%rax),%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    14f6 <mrqmin+0x386>
jp     14f6 <mrqmin+0x386>
mov    0x18(%rbp),%rdi
mov    -0x44(%rbp),%esi
mov    0x10(%rbp),%rdx
mov    0x2bcb(%rip),%ecx
call   1040 <covsrt@plt>
mov    0x2be7(%rip),%rdi
mov    0x2bb9(%rip),%edx
mov    $0x1,%r8d
mov    %r8d,%esi
mov    %r8d,%ecx
call   1090 <free_dmatrix@plt>
mov    0x2bc1(%rip),%rdi
mov    $0x1,%esi
call   1080 <free_dvector@plt>
mov    0x2ba8(%rip),%rdi
mov    $0x1,%esi
call   1080 <free_dvector@plt>
mov    0x2b8f(%rip),%rdi
mov    $0x1,%esi
call   1080 <free_dvector@plt>
mov    -0x54(%rbp),%eax
mov    %eax,-0x14(%rbp)
jmp    1807 <mrqmin+0x697>
movl   $0x0,-0x48(%rbp)
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     156a <mrqmin+0x3fa>
mov    0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1557 <mrqmin+0x3e7>
mov    -0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x2b4a(%rip),%rax
mov    -0x48(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x48(%rbp)
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    0x2b22(%rip),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    155c <mrqmin+0x3ec>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    1504 <mrqmin+0x394>
cmpq   $0x0,0x40(%rbp)
je     167c <mrqmin+0x50c>
cmpq   $0x0,0x48(%rbp)
je     167c <mrqmin+0x50c>
movl   $0x0,-0x48(%rbp)
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     1677 <mrqmin+0x507>
mov    0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cmpl   $0x0,0x4(%rax)
je     1601 <mrqmin+0x491>
mov    0x2ab9(%rip),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x48(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
ucomisd %xmm1,%xmm0
jbe    15fc <mrqmin+0x48c>
mov    0x48(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x8(%rax),%xmm0
mov    0x2a7d(%rip),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1601 <mrqmin+0x491>
mov    0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
cmpl   $0x0,0x8(%rax)
je     1664 <mrqmin+0x4f4>
mov    0x2a52(%rip),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x48(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
ucomisd 0x10(%rax),%xmm0
jbe    165f <mrqmin+0x4ef>
mov    0x48(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movsd  0x10(%rax),%xmm0
mov    0x2a1a(%rip),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1664 <mrqmin+0x4f4>
jmp    1669 <mrqmin+0x4f9>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    158e <mrqmin+0x41e>
jmp    167c <mrqmin+0x50c>
mov    -0x20(%rbp),%rdi
mov    -0x28(%rbp),%rsi
mov    -0x30(%rbp),%rdx
mov    -0x34(%rbp),%ecx
mov    0x29de(%rip),%r8
mov    0x10(%rbp),%r9
mov    -0x44(%rbp),%r14d
mov    0x18(%rbp),%rbx
mov    0x29db(%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   1060 <mrqcof@plt>
mov    0x28(%rbp),%rax
movsd  (%rax),%xmm1
movsd  0x298e(%rip),%xmm0
ucomisd %xmm1,%xmm0
jbe    17dd <mrqmin+0x66d>
mov    0x38(%rbp),%rax
movsd  0x920(%rip),%xmm0
mulsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
mov    0x28(%rbp),%rax
movsd  (%rax),%xmm0
movsd  %xmm0,0x2960(%rip)
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    0x2948(%rip),%eax
jg     179a <mrqmin+0x62a>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x2932(%rip),%eax
jg     176c <mrqmin+0x5fc>
mov    0x18(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x4c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1725 <mrqmin+0x5b5>
mov    0x290d(%rip),%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28f5(%rip),%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    170f <mrqmin+0x59f>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     17d8 <mrqmin+0x668>
mov    0x28bc(%rip),%rax
movslq -0x50(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x40(%rbp),%rax
movslq -0x50(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    17a1 <mrqmin+0x631>
jmp    1801 <mrqmin+0x691>
mov    0x38(%rbp),%rax
movsd  0x81f(%rip),%xmm0
mulsd  (%rax),%xmm0
movsd  %xmm0,(%rax)
movsd  0x286f(%rip),%xmm0
mov    0x28(%rbp),%rax
movsd  %xmm0,(%rax)
mov    -0x54(%rbp),%eax
mov    %eax,-0x14(%rbp)
mov    -0x14(%rbp),%eax
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    $0x48,%rsp
mov    %r9d,%r15d
mov    %r8,%r14
mov    %ecx,0xc(%rsp)
mov    %rdx,0x30(%rsp)
mov    %rsi,0x28(%rsp)
mov    %rdi,0x20(%rsp)
mov    0xa8(%rsp),%r13
mov    0x98(%rsp),%r12
xorpd  %xmm0,%xmm0
ucomisd 0x0(%r13),%xmm0
jbe    151b <mrqmin+0x3ab>
mov    $0x1,%edi
mov    %r15d,%esi
call   1070 <dvector@plt>
mov    %rax,0x2ea5(%rip)
mov    $0x1,%edi
mov    %r15d,%esi
call   1070 <dvector@plt>
mov    %rax,0x2e99(%rip)
mov    $0x1,%edi
mov    %r15d,%esi
call   1070 <dvector@plt>
mov    %rax,0x2e8d(%rip)
movl   $0x0,0x2e63(%rip)
movabs $0x3f50624dd2f1a9fc,%rbx
62 50 3f
test   %r15d,%r15d
jle    1322 <mrqmin+0x1b2>
mov    %r15d,%ebp
cmp    $0x1,%r15d
jne    1399 <mrqmin+0x229>
xor    %esi,%esi
mov    $0x1,%eax
mov    0x80(%rsp),%rdi
test   $0x1,%bpl
je     1241 <mrqmin+0xd1>
cmpl   $0x0,(%rdi,%rax,4)
je     1241 <mrqmin+0xd1>
add    $0x1,%esi
mov    %esi,0x2e1f(%rip)
mov    $0x1,%edi
mov    $0x1,%edx
mov    $0x1,%ecx
call   1050 <dmatrix@plt>
mov    %rax,0x2e2c(%rip)
mov    %rbx,0x0(%r13)
sub    $0x8,%rsp
mov    0x28(%rsp),%rdi
mov    0x30(%rsp),%rsi
mov    0x38(%rsp),%rdx
mov    0x14(%rsp),%ecx
mov    %r14,%r8
mov    0x88(%rsp),%r9
push   0xa8(%rsp)
push   %r12
push   0x2de7(%rip)
push   0xb0(%rsp)
push   %r15
call   1060 <mrqcof@plt>
add    $0x30,%rsp
movsd  (%r12),%xmm0
movsd  %xmm0,0x2db7(%rip)
test   %r15d,%r15d
jle    151b <mrqmin+0x3ab>
add    $0x1,%rbp
mov    0x2dab(%rip),%rax
lea    -0x1(%rbp),%rdx
mov    $0x1,%ecx
cmp    $0x4,%rdx
jb     14a7 <mrqmin+0x337>
lea    0x8(%rax),%rsi
lea    (%r14,%rbp,8),%rdi
cmp    %rdi,%rsi
jae    12f6 <mrqmin+0x186>
lea    (%rax,%rbp,8),%rsi
lea    0x8(%r14),%rdi
cmp    %rsi,%rdi
jb     14a7 <mrqmin+0x337>
mov    %rdx,%rcx
and    $0xfffffffffffffffc,%rcx
lea    -0x4(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x2,%rsi
add    $0x1,%rsi
mov    %esi,%ebx
and    $0x3,%ebx
cmp    $0xc,%rdi
jae    13f7 <mrqmin+0x287>
xor    %edi,%edi
jmp    1466 <mrqmin+0x2f6>
mov    $0x1,%edi
xor    %esi,%esi
mov    $0x1,%edx
mov    $0x1,%ecx
call   1050 <dmatrix@plt>
mov    %rax,0x2d49(%rip)
mov    %rbx,0x0(%r13)
sub    $0x8,%rsp
mov    0x28(%rsp),%rdi
mov    0x30(%rsp),%rsi
mov    0x38(%rsp),%rdx
mov    0x14(%rsp),%ecx
mov    %r14,%r8
mov    0x88(%rsp),%r9
push   0xa8(%rsp)
push   %r12
push   0x2d04(%rip)
push   0xb0(%rsp)
push   %r15
call   1060 <mrqcof@plt>
add    $0x30,%rsp
movsd  (%r12),%xmm0
movsd  %xmm0,0x2cd4(%rip)
jmp    151b <mrqmin+0x3ab>
mov    %ebp,%ecx
and    $0xfffffffe,%ecx
neg    %rcx
xor    %esi,%esi
mov    $0x1,%eax
mov    0x80(%rsp),%rdi
jmp    13d6 <mrqmin+0x266>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
je     122c <mrqmin+0xbc>
cmpl   $0x0,(%rdi,%rax,4)
je     13e5 <mrqmin+0x275>
add    $0x1,%esi
mov    %esi,0x2c7b(%rip)
cmpl   $0x0,0x4(%rdi,%rax,4)
je     13c0 <mrqmin+0x250>
add    $0x1,%esi
mov    %esi,0x2c6b(%rip)
jmp    13c0 <mrqmin+0x250>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopl   (%rax)
movups 0x8(%r14,%rdi,8),%xmm0
movups 0x18(%r14,%rdi,8),%xmm1
movups %xmm0,0x8(%rax,%rdi,8)
movups %xmm1,0x18(%rax,%rdi,8)
movups 0x28(%r14,%rdi,8),%xmm0
movups 0x38(%r14,%rdi,8),%xmm1
movups %xmm0,0x28(%rax,%rdi,8)
movups %xmm1,0x38(%rax,%rdi,8)
movups 0x48(%r14,%rdi,8),%xmm0
movups 0x58(%r14,%rdi,8),%xmm1
movups %xmm0,0x48(%rax,%rdi,8)
movups %xmm1,0x58(%rax,%rdi,8)
movupd 0x68(%r14,%rdi,8),%xmm0
movupd 0x78(%r14,%rdi,8),%xmm1
movupd %xmm0,0x68(%rax,%rdi,8)
movupd %xmm1,0x78(%rax,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1400 <mrqmin+0x290>
test   %rbx,%rbx
je     149e <mrqmin+0x32e>
nopl   0x0(%rax,%rax,1)
lea    0x0(,%rdi,8),%rsi
or     $0x8,%rsi
movupd (%r14,%rsi,1),%xmm0
movupd 0x10(%r14,%rsi,1),%xmm1
movupd %xmm0,(%rax,%rsi,1)
movupd %xmm1,0x10(%rax,%rsi,1)
add    $0x4,%rdi
add    $0xffffffffffffffff,%rbx
jne    1470 <mrqmin+0x300>
cmp    %rcx,%rdx
je     151b <mrqmin+0x3ab>
or     $0x1,%rcx
mov    %ebp,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
not    %rdx
add    %rbp,%rdx
and    $0x3,%rsi
je     14d5 <mrqmin+0x365>
nopw   0x0(%rax,%rax,1)
movsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    14c0 <mrqmin+0x350>
cmp    $0x3,%rdx
jb     151b <mrqmin+0x3ab>
nopl   0x0(%rax,%rax,1)
movsd  (%r14,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movsd  0x8(%r14,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rax,%rcx,8)
movsd  0x10(%r14,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rax,%rcx,8)
movsd  0x18(%r14,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rax,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%rbp
jne    14e0 <mrqmin+0x370>
mov    0x2b3f(%rip),%esi
test   %esi,%esi
jle    1778 <mrqmin+0x608>
mov    %r15,0x18(%rsp)
mov    %r14,0x40(%rsp)
mov    0x2b3e(%rip),%r12
mov    0x2b47(%rip),%rdx
lea    0x1(%rsi),%rcx
lea    -0x4(%rsi),%r9
mov    %r9,0x38(%rsp)
shr    $0x2,%r9
add    $0x1,%r9
mov    %esi,%r11d
and    $0xfffffffc,%r11d
lea    0x1(%r11),%rax
mov    %rax,0x10(%rsp)
mov    %r9d,%r10d
and    $0x3,%r10d
and    $0xfffffffffffffffc,%r9
mov    $0x1,%r14d
movsd  0xa81(%rip),%xmm0
mov    0x90(%rsp),%rbp
jmp    15c2 <mrqmin+0x452>
nopl   0x0(%rax)
movsd  0x0(%r13),%xmm1
addsd  %xmm0,%xmm1
mulsd  (%rbx,%r14,8),%xmm1
movsd  %xmm1,(%r15,%r14,8)
movsd  (%r12,%r14,8),%xmm1
mov    (%rdx,%r14,8),%rax
movsd  %xmm1,0x8(%rax)
add    $0x1,%r14
cmp    %rcx,%r14
je     1764 <mrqmin+0x5f4>
mov    0x0(%rbp,%r14,8),%rbx
mov    0x88(%rsp),%rax
mov    (%rax,%r14,8),%r15
mov    $0x1,%r8d
cmp    $0x4,%esi
jb     16e0 <mrqmin+0x570>
lea    0x8(%r15),%rax
lea    (%rbx,%rcx,8),%rdi
cmp    %rdi,%rax
jae    1606 <mrqmin+0x496>
lea    (%r15,%rcx,8),%rax
lea    0x8(%rbx),%rdi
mov    $0x1,%r8d
cmp    %rax,%rdi
jb     16e0 <mrqmin+0x570>
cmpq   $0xc,0x38(%rsp)
jae    1612 <mrqmin+0x4a2>
xor    %edi,%edi
jmp    1684 <mrqmin+0x514>
mov    %r9,%rax
xor    %edi,%edi
nopw   0x0(%rax,%rax,1)
movups 0x8(%rbx,%rdi,8),%xmm1
movups 0x18(%rbx,%rdi,8),%xmm2
movups %xmm1,0x8(%r15,%rdi,8)
movups %xmm2,0x18(%r15,%rdi,8)
movups 0x28(%rbx,%rdi,8),%xmm1
movups 0x38(%rbx,%rdi,8),%xmm2
movups %xmm1,0x28(%r15,%rdi,8)
movups %xmm2,0x38(%r15,%rdi,8)
movups 0x48(%rbx,%rdi,8),%xmm1
movups 0x58(%rbx,%rdi,8),%xmm2
movups %xmm1,0x48(%r15,%rdi,8)
movups %xmm2,0x58(%r15,%rdi,8)
movupd 0x68(%rbx,%rdi,8),%xmm1
movups 0x78(%rbx,%rdi,8),%xmm2
movupd %xmm1,0x68(%r15,%rdi,8)
movups %xmm2,0x78(%r15,%rdi,8)
add    $0x10,%rdi
add    $0xfffffffffffffffc,%rax
jne    1620 <mrqmin+0x4b0>
test   %r10,%r10
je     16bc <mrqmin+0x54c>
mov    %r10,%rax
nopl   0x0(%rax)
lea    0x0(,%rdi,8),%rbp
or     $0x8,%rbp
movupd (%rbx,%rbp,1),%xmm1
movups 0x10(%rbx,%rbp,1),%xmm2
movupd %xmm1,(%r15,%rbp,1)
movups %xmm2,0x10(%r15,%rbp,1)
add    $0x4,%rdi
add    $0xffffffffffffffff,%rax
jne    1690 <mrqmin+0x520>
mov    0x10(%rsp),%r8
cmp    %r11,%rsi
mov    0x90(%rsp),%rbp
je     1590 <mrqmin+0x420>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %ecx,%edi
sub    %r8d,%edi
mov    %r8,%rax
not    %rax
add    %rcx,%rax
and    $0x3,%rdi
je     1716 <mrqmin+0x5a6>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rbx,%r8,8),%xmm1
movsd  %xmm1,(%r15,%r8,8)
add    $0x1,%r8
add    $0xffffffffffffffff,%rdi
jne    1700 <mrqmin+0x590>
cmp    $0x3,%rax
jb     1590 <mrqmin+0x420>
movsd  (%rbx,%r8,8),%xmm1
movsd  %xmm1,(%r15,%r8,8)
movsd  0x8(%rbx,%r8,8),%xmm1
movsd  %xmm1,0x8(%r15,%r8,8)
movsd  0x10(%rbx,%r8,8),%xmm1
movsd  %xmm1,0x10(%r15,%r8,8)
movsd  0x18(%rbx,%r8,8),%xmm1
movsd  %xmm1,0x18(%r15,%r8,8)
add    $0x4,%r8
cmp    %r8,%rcx
jne    1720 <mrqmin+0x5b0>
jmp    1590 <mrqmin+0x420>
mov    0x40(%rsp),%r14
mov    0x18(%rsp),%r15
mov    0x98(%rsp),%r12
jmp    177f <mrqmin+0x60f>
mov    0x2909(%rip),%rdx
mov    0x88(%rsp),%rdi
mov    $0x1,%ecx
call   1030 <gaussj@plt>
mov    %eax,%ebx
test   %eax,%eax
je     187c <mrqmin+0x70c>
mov    0x28bf(%rip),%ecx
test   %ecx,%ecx
mov    0x80(%rsp),%r9
jle    1857 <mrqmin+0x6e7>
mov    0x28d0(%rip),%rdx
mov    0x28c1(%rip),%rsi
lea    -0x1(%rcx),%rbp
mov    %ecx,%eax
and    $0x3,%eax
mov    $0x1,%edi
cmp    $0x3,%rbp
jb     1830 <mrqmin+0x6c0>
mov    %ebx,%r8d
mov    %ecx,%ebp
and    $0xfffffffc,%ebp
xor    %edi,%edi
nopl   (%rax)
mov    0x8(%rdx,%rdi,8),%rbx
movsd  0x8(%rbx),%xmm0
movsd  %xmm0,0x8(%rsi,%rdi,8)
mov    0x10(%rdx,%rdi,8),%rbx
movsd  0x8(%rbx),%xmm0
movsd  %xmm0,0x10(%rsi,%rdi,8)
mov    0x18(%rdx,%rdi,8),%rbx
movsd  0x8(%rbx),%xmm0
movsd  %xmm0,0x18(%rsi,%rdi,8)
mov    0x20(%rdx,%rdi,8),%rbx
movsd  0x8(%rbx),%xmm0
movsd  %xmm0,0x20(%rsi,%rdi,8)
add    $0x4,%rdi
cmp    %rdi,%rbp
jne    17e0 <mrqmin+0x670>
add    $0x1,%rdi
mov    %r8d,%ebx
test   %rax,%rax
je     1857 <mrqmin+0x6e7>
lea    (%rsi,%rdi,8),%rsi
lea    (%rdx,%rdi,8),%rdx
xor    %edi,%edi
nop
mov    (%rdx,%rdi,8),%rbp
movsd  0x8(%rbp),%xmm0
movsd  %xmm0,(%rsi,%rdi,8)
add    $0x1,%rdi
cmp    %rdi,%rax
jne    1840 <mrqmin+0x6d0>
movsd  0x0(%r13),%xmm0
xorpd  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    18e2 <mrqmin+0x772>
jp     18e2 <mrqmin+0x772>
mov    0x88(%rsp),%rdi
mov    %r15d,%esi
mov    %r9,%rdx
call   1040 <covsrt@plt>
mov    0x2805(%rip),%rdi
mov    0x27d7(%rip),%edx
mov    $0x1,%esi
mov    $0x1,%ecx
mov    $0x1,%r8d
call   1090 <free_dmatrix@plt>
mov    0x27db(%rip),%rdi
mov    $0x1,%esi
call   1080 <free_dvector@plt>
mov    0x27c2(%rip),%rdi
mov    $0x1,%esi
call   1080 <free_dvector@plt>
mov    0x27a9(%rip),%rdi
mov    $0x1,%esi
call   1080 <free_dvector@plt>
mov    %ebx,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
test   %r15d,%r15d
jle    19be <mrqmin+0x84e>
mov    %ebx,%r8d
mov    0x278b(%rip),%rax
mov    0x2774(%rip),%rcx
mov    %r15d,%ebx
cmp    $0x1,%r15d
jne    1cc5 <mrqmin+0xb55>
xor    %edi,%edi
mov    $0x1,%esi
mov    0xb0(%rsp),%rbp
test   $0x1,%bl
je     1938 <mrqmin+0x7c8>
cmpl   $0x0,(%r9,%rsi,4)
je     1938 <mrqmin+0x7c8>
movsd  (%r14,%rsi,8),%xmm0
movslq %edi,%rdx
addsd  0x8(%rax,%rdx,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
test   %rbp,%rbp
mov    %r8d,%ebx
je     19be <mrqmin+0x84e>
mov    0xb8(%rsp),%rax
test   %rax,%rax
je     19be <mrqmin+0x84e>
test   %r15d,%r15d
jle    19be <mrqmin+0x84e>
mov    0x2717(%rip),%r8
lea    0x1(%r15),%ecx
mov    $0x1,%edx
jmp    1979 <mrqmin+0x809>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%rdx
cmp    %rdx,%rcx
je     19c5 <mrqmin+0x855>
mov    0x0(%rbp,%rdx,8),%rsi
cmpl   $0x0,0x4(%rsi)
je     199b <mrqmin+0x82b>
mov    (%rax,%rdx,8),%rdi
movsd  0x8(%rdi),%xmm0
ucomisd (%r8,%rdx,8),%xmm0
jbe    199b <mrqmin+0x82b>
movsd  %xmm0,(%r8,%rdx,8)
cmpl   $0x0,0x8(%rsi)
je     1970 <mrqmin+0x800>
movsd  (%r8,%rdx,8),%xmm1
mov    (%rax,%rdx,8),%rsi
movsd  0x10(%rsi),%xmm0
ucomisd %xmm0,%xmm1
jbe    1970 <mrqmin+0x800>
movsd  %xmm0,(%r8,%rdx,8)
jmp    1970 <mrqmin+0x800>
mov    0x26ab(%rip),%r8
sub    $0x8,%rsp
mov    0x28(%rsp),%rdi
mov    0x30(%rsp),%rsi
mov    0x38(%rsp),%rdx
mov    0x14(%rsp),%ecx
push   0xa8(%rsp)
push   %r12
push   0x2695(%rip)
push   0xa8(%rsp)
push   %r15
call   1060 <mrqcof@plt>
add    $0x30,%rsp
movsd  0x2663(%rip),%xmm1
ucomisd (%r12),%xmm1
movsd  0x0(%r13),%xmm0
jbe    1c3c <mrqmin+0xacc>
mov    %ebx,0x10(%rsp)
mov    %r15,0x18(%rsp)
mulsd  0x5e8(%rip),%xmm0
movsd  %xmm0,0x0(%r13)
movsd  (%r12),%xmm0
movsd  %xmm0,0x262c(%rip)
mov    0x261e(%rip),%eax
test   %eax,%eax
jle    1c55 <mrqmin+0xae5>
mov    0x262f(%rip),%r12
mov    0x2620(%rip),%r13
lea    0x1(%rax),%r8
lea    -0x4(%rax),%r9
mov    %r9,%r10
shr    $0x2,%r10
add    $0x1,%r10
mov    %eax,%r11d
and    $0xfffffffc,%r11d
lea    0x1(%r11),%rcx
mov    %rcx,0x38(%rsp)
mov    %r10d,%r15d
and    $0x3,%r15d
and    $0xfffffffffffffffc,%r10
mov    $0x1,%ebp
jmp    1aaa <mrqmin+0x93a>
nopl   (%rax)
movsd  (%r12,%rbp,8),%xmm0
movsd  %xmm0,0x0(%r13,%rbp,8)
add    $0x1,%rbp
cmp    %r8,%rbp
je     1c55 <mrqmin+0xae5>
mov    0x88(%rsp),%rcx
mov    (%rcx,%rbp,8),%rbx
mov    0x90(%rsp),%rcx
mov    (%rcx,%rbp,8),%rdi
mov    $0x1,%ecx
cmp    $0x4,%eax
jb     1bc0 <mrqmin+0xa50>
lea    0x8(%rdi),%rcx
lea    (%rbx,%r8,8),%rdx
cmp    %rdx,%rcx
jae    1af3 <mrqmin+0x983>
lea    (%rdi,%r8,8),%rdx
lea    0x8(%rbx),%rsi
mov    $0x1,%ecx
cmp    %rdx,%rsi
jb     1bc0 <mrqmin+0xa50>
cmp    $0xc,%r9
jae    1afd <mrqmin+0x98d>
xor    %ecx,%ecx
jmp    1b6e <mrqmin+0x9fe>
mov    %r10,%rdx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups 0x8(%rbx,%rcx,8),%xmm0
movups 0x18(%rbx,%rcx,8),%xmm1
movups %xmm0,0x8(%rdi,%rcx,8)
movups %xmm1,0x18(%rdi,%rcx,8)
movups 0x28(%rbx,%rcx,8),%xmm0
movups 0x38(%rbx,%rcx,8),%xmm1
movups %xmm0,0x28(%rdi,%rcx,8)
movups %xmm1,0x38(%rdi,%rcx,8)
movups 0x48(%rbx,%rcx,8),%xmm0
movups 0x58(%rbx,%rcx,8),%xmm1
movups %xmm0,0x48(%rdi,%rcx,8)
movups %xmm1,0x58(%rdi,%rcx,8)
movupd 0x68(%rbx,%rcx,8),%xmm0
movupd 0x78(%rbx,%rcx,8),%xmm1
movupd %xmm0,0x68(%rdi,%rcx,8)
movupd %xmm1,0x78(%rdi,%rcx,8)
add    $0x10,%rcx
add    $0xfffffffffffffffc,%rdx
jne    1b10 <mrqmin+0x9a0>
test   %r15,%r15
je     1bac <mrqmin+0xa3c>
mov    %r15,%rdx
cs nopw 0x0(%rax,%rax,1)
lea    0x0(,%rcx,8),%rsi
or     $0x8,%rsi
movupd (%rbx,%rsi,1),%xmm0
movupd 0x10(%rbx,%rsi,1),%xmm1
movupd %xmm0,(%rdi,%rsi,1)
movupd %xmm1,0x10(%rdi,%rsi,1)
add    $0x4,%rcx
add    $0xffffffffffffffff,%rdx
jne    1b80 <mrqmin+0xa10>
mov    0x38(%rsp),%rcx
cmp    %r11,%rax
je     1a90 <mrqmin+0x920>
nopw   0x0(%rax,%rax,1)
mov    %r8d,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
not    %rdx
add    %r8,%rdx
and    $0x3,%rsi
je     1bf4 <mrqmin+0xa84>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rcx,8)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1be0 <mrqmin+0xa70>
cmp    $0x3,%rdx
jb     1a90 <mrqmin+0x920>
xchg   %ax,%ax
movsd  (%rbx,%rcx,8),%xmm0
movsd  %xmm0,(%rdi,%rcx,8)
movsd  0x8(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x8(%rdi,%rcx,8)
movsd  0x10(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x10(%rdi,%rcx,8)
movsd  0x18(%rbx,%rcx,8),%xmm0
movsd  %xmm0,0x18(%rdi,%rcx,8)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1c00 <mrqmin+0xa90>
jmp    1a90 <mrqmin+0x920>
mulsd  0x3c4(%rip),%xmm0
movsd  %xmm0,0x0(%r13)
movsd  %xmm1,(%r12)
jmp    18d1 <mrqmin+0x761>
mov    0x18(%rsp),%rdi
test   %edi,%edi
mov    0x10(%rsp),%ebx
jle    18d1 <mrqmin+0x761>
mov    0x2403(%rip),%rax
mov    %edi,%esi
lea    0x1(%rsi),%rcx
mov    $0x1,%edx
cmp    $0x4,%edi
jb     1def <mrqmin+0xc7f>
lea    0x8(%r14),%rdi
lea    (%rax,%rcx,8),%rbp
cmp    %rbp,%rdi
jae    1c9f <mrqmin+0xb2f>
lea    (%r14,%rcx,8),%rdi
lea    0x8(%rax),%rbp
cmp    %rdi,%rbp
jb     1def <mrqmin+0xc7f>
mov    %esi,%edx
and    $0xfffffffc,%edx
lea    -0x4(%rdx),%rbp
mov    %rbp,%rdi
shr    $0x2,%rdi
add    $0x1,%rdi
mov    %edi,%ebx
and    $0x3,%ebx
cmp    $0xc,%rbp
jae    1d37 <mrqmin+0xbc7>
xor    %ebp,%ebp
jmp    1da6 <mrqmin+0xc36>
mov    %ebx,%edx
and    $0xfffffffe,%edx
neg    %rdx
xor    %edi,%edi
mov    $0x1,%esi
jmp    1cf6 <mrqmin+0xb86>
cs nopw 0x0(%rax,%rax,1)
lea    (%rdx,%rsi,1),%rbp
add    $0x2,%rbp
add    $0x2,%rsi
cmp    $0x1,%rbp
je     1910 <mrqmin+0x7a0>
cmpl   $0x0,(%r9,%rsi,4)
je     1d14 <mrqmin+0xba4>
movsd  (%r14,%rsi,8),%xmm0
movslq %edi,%rbp
add    $0x1,%edi
addsd  0x8(%rax,%rbp,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,8)
cmpl   $0x0,0x4(%r9,%rsi,4)
je     1ce0 <mrqmin+0xb70>
movsd  0x8(%r14,%rsi,8),%xmm0
movslq %edi,%rbp
add    $0x1,%edi
addsd  0x8(%rax,%rbp,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rsi,8)
jmp    1ce0 <mrqmin+0xb70>
and    $0xfffffffffffffffc,%rdi
xor    %ebp,%ebp
nopl   (%rax)
movups 0x8(%rax,%rbp,8),%xmm0
movups 0x18(%rax,%rbp,8),%xmm1
movups %xmm0,0x8(%r14,%rbp,8)
movups %xmm1,0x18(%r14,%rbp,8)
movups 0x28(%rax,%rbp,8),%xmm0
movups 0x38(%rax,%rbp,8),%xmm1
movups %xmm0,0x28(%r14,%rbp,8)
movups %xmm1,0x38(%r14,%rbp,8)
movups 0x48(%rax,%rbp,8),%xmm0
movups 0x58(%rax,%rbp,8),%xmm1
movups %xmm0,0x48(%r14,%rbp,8)
movups %xmm1,0x58(%r14,%rbp,8)
movupd 0x68(%rax,%rbp,8),%xmm0
movupd 0x78(%rax,%rbp,8),%xmm1
movupd %xmm0,0x68(%r14,%rbp,8)
movupd %xmm1,0x78(%r14,%rbp,8)
add    $0x10,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1d40 <mrqmin+0xbd0>
test   %rbx,%rbx
je     1dde <mrqmin+0xc6e>
nopl   0x0(%rax,%rax,1)
lea    0x0(,%rbp,8),%rdi
or     $0x8,%rdi
movupd (%rax,%rdi,1),%xmm0
movupd 0x10(%rax,%rdi,1),%xmm1
movupd %xmm0,(%r14,%rdi,1)
movupd %xmm1,0x10(%r14,%rdi,1)
add    $0x4,%rbp
add    $0xffffffffffffffff,%rbx
jne    1db0 <mrqmin+0xc40>
cmp    %rdx,%rsi
mov    0x10(%rsp),%ebx
je     18d1 <mrqmin+0x761>
or     $0x1,%rdx
mov    %ecx,%edi
sub    %edx,%edi
mov    %rdx,%rsi
not    %rsi
add    %rcx,%rsi
and    $0x3,%rdi
je     1e25 <mrqmin+0xcb5>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,(%r14,%rdx,8)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1e10 <mrqmin+0xca0>
cmp    $0x3,%rsi
jb     18d1 <mrqmin+0x761>
nop
movsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,(%r14,%rdx,8)
movsd  0x8(%rax,%rdx,8),%xmm0
movsd  %xmm0,0x8(%r14,%rdx,8)
movsd  0x10(%rax,%rdx,8),%xmm0
movsd  %xmm0,0x10(%r14,%rdx,8)
movsd  0x18(%rax,%rdx,8),%xmm0
movsd  %xmm0,0x18(%r14,%rdx,8)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1e30 <mrqmin+0xcc0>
jmp    18d1 <mrqmin+0x761>

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

LLVM IR (-O2):
@mrqmin.mfit = internal unnamed_addr global i32 0
@mrqmin.ochisq = internal unnamed_addr global double 0.000000e+00
@mrqmin.atry = internal unnamed_addr global double* null
@mrqmin.beta = internal unnamed_addr global double* null
@mrqmin.da = internal unnamed_addr global double* null
@mrqmin.oneda = internal unnamed_addr global double** null
define i32 @mrqmin(float* %0, float* %1, float* %2, i32 %3, double* %4, i32 %5, i32* %6, double** %7, double** %8, double* %9, void (float, double*, double*, double*, i32)* %10, double* nocapture %11, i32** %12, double** %13) {
%15 = load double, double* %11
%16 = fcmp olt double %15, 0.000000e+00
br i1 %16, label %17, label %208
17: ; preds = %14
%18 = tail call double* @dvector(i32 1, i32 %5)
store double* %18, double** @mrqmin.atry
%19 = tail call double* @dvector(i32 1, i32 %5)
store double* %19, double** @mrqmin.beta
%20 = tail call double* @dvector(i32 1, i32 %5)
store double* %20, double** @mrqmin.da
store i32 0, i32* @mrqmin.mfit
%21 = icmp slt i32 %5, 1
br i1 %21, label %203, label %22
22: ; preds = %17
%23 = add nuw i32 %5, 1
%24 = zext i32 %23 to i64
%25 = add nsw i64 %24, -1
%26 = and i64 %25, 1
%27 = icmp eq i32 %23, 2
br i1 %27, label %52, label %28
28: ; preds = %22
%29 = and i64 %25, -2
br label %30
30: ; preds = %47, %28
%31 = phi i64 [ 1, %28 ], [ %49, %47 ]
%32 = phi i32 [ 0, %28 ], [ %48, %47 ]
%33 = phi i64 [ 0, %28 ], [ %50, %47 ]
%34 = getelementptr inbounds i32, i32* %6, i64 %31
%35 = load i32, i32* %34
%36 = icmp eq i32 %35, 0
br i1 %36, label %39, label %37
37: ; preds = %30
%38 = add nsw i32 %32, 1
store i32 %38, i32* @mrqmin.mfit
br label %39
39: ; preds = %30, %37
%40 = phi i32 [ %32, %30 ], [ %38, %37 ]
%41 = add nuw nsw i64 %31, 1
%42 = getelementptr inbounds i32, i32* %6, i64 %41
%43 = load i32, i32* %42
%44 = icmp eq i32 %43, 0
br i1 %44, label %47, label %45
45: ; preds = %39
%46 = add nsw i32 %40, 1
store i32 %46, i32* @mrqmin.mfit
br label %47
47: ; preds = %45, %39
%48 = phi i32 [ %40, %39 ], [ %46, %45 ]
%49 = add nuw nsw i64 %31, 2
%50 = add i64 %33, 2
%51 = icmp eq i64 %50, %29
br i1 %51, label %52, label %30
52: ; preds = %47, %22
%53 = phi i32 [ undef, %22 ], [ %48, %47 ]
%54 = phi i64 [ 1, %22 ], [ %49, %47 ]
%55 = phi i32 [ 0, %22 ], [ %48, %47 ]
%56 = icmp eq i64 %26, 0
br i1 %56, label %63, label %57
57: ; preds = %52
%58 = getelementptr inbounds i32, i32* %6, i64 %54
%59 = load i32, i32* %58
%60 = icmp eq i32 %59, 0
br i1 %60, label %63, label %61
61: ; preds = %57
%62 = add nsw i32 %55, 1
store i32 %62, i32* @mrqmin.mfit
br label %63
63: ; preds = %57, %61, %52
%64 = phi i32 [ %53, %52 ], [ %55, %57 ], [ %62, %61 ]
%65 = tail call double** @dmatrix(i32 1, i32 %64, i32 1, i32 1)
store double** %65, double*** @mrqmin.oneda
store double 1.000000e-03, double* %11
%66 = load double*, double** @mrqmin.beta
%67 = tail call i32 @mrqcof(float* %0, float* %1, float* %2, i32 %3, double* %4, i32* %6, i32 %5, double** %8, double* %66, double* %9, void (float, double*, double*, double*, i32)* %10)
%68 = load double, double* %9
store double %68, double* @mrqmin.ochisq
br i1 %21, label %208, label %69
69: ; preds = %63
%70 = load double*, double** @mrqmin.atry
%71 = add nuw i32 %5, 1
%72 = zext i32 %71 to i64
%73 = add nsw i64 %24, -1
%74 = icmp ult i64 %73, 4
br i1 %74, label %165, label %75
75: ; preds = %69
%76 = getelementptr double, double* %70, i64 1
%77 = getelementptr double, double* %70, i64 %24
%78 = getelementptr double, double* %4, i64 1
%79 = getelementptr double, double* %4, i64 %24
%80 = icmp ult double* %76, %79
%81 = icmp ult double* %78, %77
%82 = and i1 %80, %81
br i1 %82, label %165, label %83
83: ; preds = %75
%84 = and i64 %73, -4
%85 = or i64 %84, 1
%86 = add nsw i64 %84, -4
%87 = lshr exact i64 %86, 2
%88 = add nuw nsw i64 %87, 1
%89 = and i64 %88, 3
%90 = icmp ult i64 %86, 12
br i1 %90, label %143, label %91
91: ; preds = %83
%92 = and i64 %88, 9223372036854775804
br label %93
93: ; preds = %93, %91
%94 = phi i64 [ 0, %91 ], [ %140, %93 ]
%95 = phi i64 [ 0, %91 ], [ %141, %93 ]
%96 = or i64 %94, 1
%97 = getelementptr inbounds double, double* %4, i64 %96
%98 = bitcast double* %97 to <2 x double>*
%99 = load <2 x double>, <2 x double>* %98
%100 = getelementptr inbounds double, double* %97, i64 2
%101 = bitcast double* %100 to <2 x double>*
%102 = load <2 x double>, <2 x double>* %101
%103 = getelementptr inbounds double, double* %70, i64 %96
%104 = bitcast double* %103 to <2 x double>*
store <2 x double> %99, <2 x double>* %104
%105 = getelementptr inbounds double, double* %103, i64 2
%106 = bitcast double* %105 to <2 x double>*
store <2 x double> %102, <2 x double>* %106
%107 = or i64 %94, 5
%108 = getelementptr inbounds double, double* %4, i64 %107
%109 = bitcast double* %108 to <2 x double>*
%110 = load <2 x double>, <2 x double>* %109
%111 = getelementptr inbounds double, double* %108, i64 2
%112 = bitcast double* %111 to <2 x double>*
%113 = load <2 x double>, <2 x double>* %112
%114 = getelementptr inbounds double, double* %70, i64 %107
%115 = bitcast double* %114 to <2 x double>*
store <2 x double> %110, <2 x double>* %115
%116 = getelementptr inbounds double, double* %114, i64 2
%117 = bitcast double* %116 to <2 x double>*
store <2 x double> %113, <2 x double>* %117
%118 = or i64 %94, 9
%119 = getelementptr inbounds double, double* %4, i64 %118
%120 = bitcast double* %119 to <2 x double>*
%121 = load <2 x double>, <2 x double>* %120
%122 = getelementptr inbounds double, double* %119, i64 2
%123 = bitcast double* %122 to <2 x double>*
%124 = load <2 x double>, <2 x double>* %123
%125 = getelementptr inbounds double, double* %70, i64 %118
%126 = bitcast double* %125 to <2 x double>*
store <2 x double> %121, <2 x double>* %126
%127 = getelementptr inbounds double, double* %125, i64 2
%128 = bitcast double* %127 to <2 x double>*
store <2 x double> %124, <2 x double>* %128
%129 = or i64 %94, 13
%130 = getelementptr inbounds double, double* %4, i64 %129
%131 = bitcast double* %130 to <2 x double>*
%132 = load <2 x double>, <2 x double>* %131
%133 = getelementptr inbounds double, double* %130, i64 2
%134 = bitcast double* %133 to <2 x double>*
%135 = load <2 x double>, <2 x double>* %134
%136 = getelementptr inbounds double, double* %70, i64 %129
%137 = bitcast double* %136 to <2 x double>*
store <2 x double> %132, <2 x double>* %137
%138 = getelementptr inbounds double, double* %136, i64 2
%139 = bitcast double* %138 to <2 x double>*
store <2 x double> %135, <2 x double>* %139
%140 = add nuw i64 %94, 16
%141 = add nuw i64 %95, 4
%142 = icmp eq i64 %141, %92
br i1 %142, label %143, label %93
143: ; preds = %93, %83
%144 = phi i64 [ 0, %83 ], [ %140, %93 ]
%145 = icmp eq i64 %89, 0
br i1 %145, label %163, label %146
146: ; preds = %143, %146
%147 = phi i64 [ %160, %146 ], [ %144, %143 ]
%148 = phi i64 [ %161, %146 ], [ 0, %143 ]
%149 = or i64 %147, 1
%150 = getelementptr inbounds double, double* %4, i64 %149
%151 = bitcast double* %150 to <2 x double>*
%152 = load <2 x double>, <2 x double>* %151
%153 = getelementptr inbounds double, double* %150, i64 2
%154 = bitcast double* %153 to <2 x double>*
%155 = load <2 x double>, <2 x double>* %154
%156 = getelementptr inbounds double, double* %70, i64 %149
%157 = bitcast double* %156 to <2 x double>*
store <2 x double> %152, <2 x double>* %157
%158 = getelementptr inbounds double, double* %156, i64 2
%159 = bitcast double* %158 to <2 x double>*
store <2 x double> %155, <2 x double>* %159
%160 = add nuw i64 %147, 4
%161 = add i64 %148, 1
%162 = icmp eq i64 %161, %89
br i1 %162, label %163, label %146
163: ; preds = %146, %143
%164 = icmp eq i64 %73, %84
br i1 %164, label %208, label %165
165: ; preds = %75, %69, %163
%166 = phi i64 [ 1, %75 ], [ 1, %69 ], [ %85, %163 ]
%167 = sub nsw i64 %24, %166
%168 = xor i64 %166, -1
%169 = add nsw i64 %168, %24
%170 = and i64 %167, 3
%171 = icmp eq i64 %170, 0
br i1 %171, label %181, label %172
172: ; preds = %165, %172
%173 = phi i64 [ %178, %172 ], [ %166, %165 ]
%174 = phi i64 [ %179, %172 ], [ 0, %165 ]
%175 = getelementptr inbounds double, double* %4, i64 %173
%176 = load double, double* %175
%177 = getelementptr inbounds double, double* %70, i64 %173
store double %176, double* %177
%178 = add nuw nsw i64 %173, 1
%179 = add i64 %174, 1
%180 = icmp eq i64 %179, %170
br i1 %180, label %181, label %172
181: ; preds = %172, %165
%182 = phi i64 [ %166, %165 ], [ %178, %172 ]
%183 = icmp ult i64 %169, 3
br i1 %183, label %208, label %184
184: ; preds = %181, %184
%185 = phi i64 [ %201, %184 ], [ %182, %181 ]
%186 = getelementptr inbounds double, double* %4, i64 %185
%187 = load double, double* %186
%188 = getelementptr inbounds double, double* %70, i64 %185
store double %187, double* %188
%189 = add nuw nsw i64 %185, 1
%190 = getelementptr inbounds double, double* %4, i64 %189
%191 = load double, double* %190
%192 = getelementptr inbounds double, double* %70, i64 %189
store double %191, double* %192
%193 = add nuw nsw i64 %185, 2
%194 = getelementptr inbounds double, double* %4, i64 %193
%195 = load double, double* %194
%196 = getelementptr inbounds double, double* %70, i64 %193
store double %195, double* %196
%197 = add nuw nsw i64 %185, 3
%198 = getelementptr inbounds double, double* %4, i64 %197
%199 = load double, double* %198
%200 = getelementptr inbounds double, double* %70, i64 %197
store double %199, double* %200
%201 = add nuw nsw i64 %185, 4
%202 = icmp eq i64 %201, %72
br i1 %202, label %208, label %184
203: ; preds = %17
%204 = tail call double** @dmatrix(i32 1, i32 0, i32 1, i32 1)
store double** %204, double*** @mrqmin.oneda
store double 1.000000e-03, double* %11
%205 = load double*, double** @mrqmin.beta
%206 = tail call i32 @mrqcof(float* %0, float* %1, float* %2, i32 %3, double* %4, i32* %6, i32 %5, double** %8, double* %205, double* %9, void (float, double*, double*, double*, i32)* %10)
%207 = load double, double* %9
store double %207, double* @mrqmin.ochisq
br label %208
208: ; preds = %181, %184, %163, %203, %63, %14
%209 = load i32, i32* @mrqmin.mfit
%210 = icmp slt i32 %209, 1
br i1 %210, label %211, label %213
211: ; preds = %208
%212 = load double**, double*** @mrqmin.oneda
br label %367
213: ; preds = %208
%214 = load double*, double** @mrqmin.beta
%215 = load double**, double*** @mrqmin.oneda
%216 = add nuw i32 %209, 1
%217 = zext i32 %216 to i64
%218 = add nsw i64 %217, -1
%219 = add nsw i64 %217, -5
%220 = lshr i64 %219, 2
%221 = add nuw nsw i64 %220, 1
%222 = icmp ult i64 %218, 4
%223 = and i64 %218, -4
%224 = or i64 %223, 1
%225 = and i64 %221, 3
%226 = icmp ult i64 %219, 12
%227 = and i64 %221, 9223372036854775804
%228 = icmp eq i64 %225, 0
%229 = icmp eq i64 %218, %223
br label %230
230: ; preds = %353, %213
%231 = phi i64 [ 1, %213 ], [ %365, %353 ]
%232 = getelementptr inbounds double*, double** %8, i64 %231
%233 = load double*, double** %232
%234 = getelementptr inbounds double*, double** %7, i64 %231
%235 = load double*, double** %234
br i1 %222, label %315, label %236
236: ; preds = %230
%237 = getelementptr double, double* %235, i64 1
%238 = getelementptr double, double* %235, i64 %217
%239 = getelementptr double, double* %233, i64 1
%240 = getelementptr double, double* %233, i64 %217
%241 = icmp ult double* %237, %240
%242 = icmp ult double* %239, %238
%243 = and i1 %241, %242
br i1 %243, label %315, label %244
244: ; preds = %236
br i1 %226, label %295, label %245
245: ; preds = %244, %245
%246 = phi i64 [ %292, %245 ], [ 0, %244 ]
%247 = phi i64 [ %293, %245 ], [ 0, %244 ]
%248 = or i64 %246, 1
%249 = getelementptr inbounds double, double* %233, i64 %248
%250 = bitcast double* %249 to <2 x double>*
%251 = load <2 x double>, <2 x double>* %250
%252 = getelementptr inbounds double, double* %249, i64 2
%253 = bitcast double* %252 to <2 x double>*
%254 = load <2 x double>, <2 x double>* %253
%255 = getelementptr inbounds double, double* %235, i64 %248
%256 = bitcast double* %255 to <2 x double>*
store <2 x double> %251, <2 x double>* %256
%257 = getelementptr inbounds double, double* %255, i64 2
%258 = bitcast double* %257 to <2 x double>*
store <2 x double> %254, <2 x double>* %258
%259 = or i64 %246, 5
%260 = getelementptr inbounds double, double* %233, i64 %259
%261 = bitcast double* %260 to <2 x double>*
%262 = load <2 x double>, <2 x double>* %261
%263 = getelementptr inbounds double, double* %260, i64 2
%264 = bitcast double* %263 to <2 x double>*
%265 = load <2 x double>, <2 x double>* %264
%266 = getelementptr inbounds double, double* %235, i64 %259
%267 = bitcast double* %266 to <2 x double>*
store <2 x double> %262, <2 x double>* %267
%268 = getelementptr inbounds double, double* %266, i64 2
%269 = bitcast double* %268 to <2 x double>*
store <2 x double> %265, <2 x double>* %269
%270 = or i64 %246, 9
%271 = getelementptr inbounds double, double* %233, i64 %270
%272 = bitcast double* %271 to <2 x double>*
%273 = load <2 x double>, <2 x double>* %272
%274 = getelementptr inbounds double, double* %271, i64 2
%275 = bitcast double* %274 to <2 x double>*
%276 = load <2 x double>, <2 x double>* %275
%277 = getelementptr inbounds double, double* %235, i64 %270
%278 = bitcast double* %277 to <2 x double>*
store <2 x double> %273, <2 x double>* %278
%279 = getelementptr inbounds double, double* %277, i64 2
%280 = bitcast double* %279 to <2 x double>*
store <2 x double> %276, <2 x double>* %280
%281 = or i64 %246, 13
%282 = getelementptr inbounds double, double* %233, i64 %281
%283 = bitcast double* %282 to <2 x double>*
%284 = load <2 x double>, <2 x double>* %283
%285 = getelementptr inbounds double, double* %282, i64 2
%286 = bitcast double* %285 to <2 x double>*
%287 = load <2 x double>, <2 x double>* %286
%288 = getelementptr inbounds double, double* %235, i64 %281
%289 = bitcast double* %288 to <2 x double>*
store <2 x double> %284, <2 x double>* %289
%290 = getelementptr inbounds double, double* %288, i64 2
%291 = bitcast double* %290 to <2 x double>*
store <2 x double> %287, <2 x double>* %291
%292 = add nuw i64 %246, 16
%293 = add nuw i64 %247, 4
%294 = icmp eq i64 %293, %227
br i1 %294, label %295, label %245
295: ; preds = %245, %244
%296 = phi i64 [ 0, %244 ], [ %292, %245 ]
br i1 %228, label %314, label %297
297: ; preds = %295, %297
%298 = phi i64 [ %311, %297 ], [ %296, %295 ]
%299 = phi i64 [ %312, %297 ], [ 0, %295 ]
%300 = or i64 %298, 1
%301 = getelementptr inbounds double, double* %233, i64 %300
%302 = bitcast double* %301 to <2 x double>*
%303 = load <2 x double>, <2 x double>* %302
%304 = getelementptr inbounds double, double* %301, i64 2
%305 = bitcast double* %304 to <2 x double>*
%306 = load <2 x double>, <2 x double>* %305
%307 = getelementptr inbounds double, double* %235, i64 %300
%308 = bitcast double* %307 to <2 x double>*
store <2 x double> %303, <2 x double>* %308
%309 = getelementptr inbounds double, double* %307, i64 2
%310 = bitcast double* %309 to <2 x double>*
store <2 x double> %306, <2 x double>* %310
%311 = add nuw i64 %298, 4
%312 = add i64 %299, 1
%313 = icmp eq i64 %312, %225
br i1 %313, label %314, label %297
314: ; preds = %297, %295
br i1 %229, label %353, label %315
315: ; preds = %236, %230, %314
%316 = phi i64 [ 1, %236 ], [ 1, %230 ], [ %224, %314 ]
%317 = sub nsw i64 %217, %316
%318 = xor i64 %316, -1
%319 = add nsw i64 %318, %217
%320 = and i64 %317, 3
%321 = icmp eq i64 %320, 0
br i1 %321, label %331, label %322
322: ; preds = %315, %322
%323 = phi i64 [ %328, %322 ], [ %316, %315 ]
%324 = phi i64 [ %329, %322 ], [ 0, %315 ]
%325 = getelementptr inbounds double, double* %233, i64 %323
%326 = load double, double* %325
%327 = getelementptr inbounds double, double* %235, i64 %323
store double %326, double* %327
%328 = add nuw nsw i64 %323, 1
%329 = add i64 %324, 1
%330 = icmp eq i64 %329, %320
br i1 %330, label %331, label %322
331: ; preds = %322, %315
%332 = phi i64 [ %316, %315 ], [ %328, %322 ]
%333 = icmp ult i64 %319, 3
br i1 %333, label %353, label %334
334: ; preds = %331, %334
%335 = phi i64 [ %351, %334 ], [ %332, %331 ]
%336 = getelementptr inbounds double, double* %233, i64 %335
%337 = load double, double* %336
%338 = getelementptr inbounds double, double* %235, i64 %335
store double %337, double* %338
%339 = add nuw nsw i64 %335, 1
%340 = getelementptr inbounds double, double* %233, i64 %339
%341 = load double, double* %340
%342 = getelementptr inbounds double, double* %235, i64 %339
store double %341, double* %342
%343 = add nuw nsw i64 %335, 2
%344 = getelementptr inbounds double, double* %233, i64 %343
%345 = load double, double* %344
%346 = getelementptr inbounds double, double* %235, i64 %343
store double %345, double* %346
%347 = add nuw nsw i64 %335, 3
%348 = getelementptr inbounds double, double* %233, i64 %347
%349 = load double, double* %348
%350 = getelementptr inbounds double, double* %235, i64 %347
store double %349, double* %350
%351 = add nuw nsw i64 %335, 4
%352 = icmp eq i64 %351, %217
br i1 %352, label %353, label %334
353: ; preds = %331, %334, %314
%354 = getelementptr inbounds double, double* %233, i64 %231
%355 = load double, double* %354
%356 = load double, double* %11
%357 = fadd double %356, 1.000000e+00
%358 = fmul double %355, %357
%359 = getelementptr inbounds double, double* %235, i64 %231
store double %358, double* %359
%360 = getelementptr inbounds double, double* %214, i64 %231
%361 = load double, double* %360
%362 = getelementptr inbounds double*, double** %215, i64 %231
%363 = load double*, double** %362
%364 = getelementptr inbounds double, double* %363, i64 1
store double %361, double* %364
%365 = add nuw nsw i64 %231, 1
%366 = icmp eq i64 %365, %217
br i1 %366, label %367, label %230
367: ; preds = %353, %211
%368 = phi double** [ %212, %211 ], [ %215, %353 ]
%369 = tail call i32 @gaussj(double** %7, i32 %209, double** %368, i32 1)
%370 = icmp eq i32 %369, 0
br i1 %370, label %443, label %371
371: ; preds = %367
%372 = load i32, i32* @mrqmin.mfit
%373 = icmp slt i32 %372, 1
br i1 %373, label %428, label %374
374: ; preds = %371
%375 = load double**, double*** @mrqmin.oneda
%376 = load double*, double** @mrqmin.da
%377 = add nuw i32 %372, 1
%378 = zext i32 %377 to i64
%379 = add nsw i64 %378, -1
%380 = add nsw i64 %378, -2
%381 = and i64 %379, 3
%382 = icmp ult i64 %380, 3
br i1 %382, label %414, label %383
383: ; preds = %374
%384 = and i64 %379, -4
br label %385
385: ; preds = %385, %383
%386 = phi i64 [ 1, %383 ], [ %411, %385 ]
%387 = phi i64 [ 0, %383 ], [ %412, %385 ]
%388 = getelementptr inbounds double*, double** %375, i64 %386
%389 = load double*, double** %388
%390 = getelementptr inbounds double, double* %389, i64 1
%391 = load double, double* %390
%392 = getelementptr inbounds double, double* %376, i64 %386
store double %391, double* %392
%393 = add nuw nsw i64 %386, 1
%394 = getelementptr inbounds double*, double** %375, i64 %393
%395 = load double*, double** %394
%396 = getelementptr inbounds double, double* %395, i64 1
%397 = load double, double* %396
%398 = getelementptr inbounds double, double* %376, i64 %393
store double %397, double* %398
%399 = add nuw nsw i64 %386, 2
%400 = getelementptr inbounds double*, double** %375, i64 %399
%401 = load double*, double** %400
%402 = getelementptr inbounds double, double* %401, i64 1
%403 = load double, double* %402
%404 = getelementptr inbounds double, double* %376, i64 %399
store double %403, double* %404
%405 = add nuw nsw i64 %386, 3
%406 = getelementptr inbounds double*, double** %375, i64 %405
%407 = load double*, double** %406
%408 = getelementptr inbounds double, double* %407, i64 1
%409 = load double, double* %408
%410 = getelementptr inbounds double, double* %376, i64 %405
store double %409, double* %410
%411 = add nuw nsw i64 %386, 4
%412 = add i64 %387, 4
%413 = icmp eq i64 %412, %384
br i1 %413, label %414, label %385
414: ; preds = %385, %374
%415 = phi i64 [ 1, %374 ], [ %411, %385 ]
%416 = icmp eq i64 %381, 0
br i1 %416, label %428, label %417
417: ; preds = %414, %417
%418 = phi i64 [ %425, %417 ], [ %415, %414 ]
%419 = phi i64 [ %426, %417 ], [ 0, %414 ]
%420 = getelementptr inbounds double*, double** %375, i64 %418
%421 = load double*, double** %420
%422 = getelementptr inbounds double, double* %421, i64 1
%423 = load double, double* %422
%424 = getelementptr inbounds double, double* %376, i64 %418
store double %423, double* %424
%425 = add nuw nsw i64 %418, 1
%426 = add i64 %419, 1
%427 = icmp eq i64 %426, %381
br i1 %427, label %428, label %417
428: ; preds = %414, %417, %371
%429 = load double, double* %11
%430 = fcmp oeq double %429, 0.000000e+00
br i1 %430, label %441, label %431
431: ; preds = %428
%432 = icmp slt i32 %5, 1
br i1 %432, label %511, label %433
433: ; preds = %431
%434 = load double*, double** @mrqmin.da
%435 = load double*, double** @mrqmin.atry
%436 = zext i32 %5 to i64
%437 = and i64 %436, 1
%438 = icmp eq i32 %5, 1
br i1 %438, label %489, label %439
439: ; preds = %433
%440 = and i64 %436, 4294967294
br label %453
441: ; preds = %428
%442 = tail call i32 @covsrt(double** %7, i32 %5, i32* %6, i32 %372)
br label %443
443: ; preds = %367, %441
%444 = load double**, double*** @mrqmin.oneda
%445 = load i32, i32* @mrqmin.mfit
%446 = tail call i32 @free_dmatrix(double** %444, i32 1, i32 %445, i32 1, i32 1)
%447 = load double*, double** @mrqmin.da
%448 = tail call i32 @free_dvector(double* %447, i32 1)
%449 = load double*, double** @mrqmin.beta
%450 = tail call i32 @free_dvector(double* %449, i32 1)
%451 = load double*, double** @mrqmin.atry
%452 = tail call i32 @free_dvector(double* %451, i32 1)
br label %845
453: ; preds = %484, %439
%454 = phi i64 [ 1, %439 ], [ %486, %484 ]
%455 = phi i32 [ 0, %439 ], [ %485, %484 ]
%456 = phi i64 [ 0, %439 ], [ %487, %484 ]
%457 = getelementptr inbounds i32, i32* %6, i64 %454
%458 = load i32, i32* %457
%459 = icmp eq i32 %458, 0
br i1 %459, label %469, label %460
460: ; preds = %453
%461 = getelementptr inbounds double, double* %4, i64 %454
%462 = load double, double* %461
%463 = add nsw i32 %455, 1
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds double, double* %434, i64 %464
%466 = load double, double* %465
%467 = fadd double %462, %466
%468 = getelementptr inbounds double, double* %435, i64 %454
store double %467, double* %468
br label %469
469: ; preds = %453, %460
%470 = phi i32 [ %463, %460 ], [ %455, %453 ]
%471 = add nuw nsw i64 %454, 1
%472 = getelementptr inbounds i32, i32* %6, i64 %471
%473 = load i32, i32* %472
%474 = icmp eq i32 %473, 0
br i1 %474, label %484, label %475
475: ; preds = %469
%476 = getelementptr inbounds double, double* %4, i64 %471
%477 = load double, double* %476
%478 = add nsw i32 %470, 1
%479 = sext i32 %478 to i64
%480 = getelementptr inbounds double, double* %434, i64 %479
%481 = load double, double* %480
%482 = fadd double %477, %481
%483 = getelementptr inbounds double, double* %435, i64 %471
store double %482, double* %483
br label %484
484: ; preds = %475, %469
%485 = phi i32 [ %478, %475 ], [ %470, %469 ]
%486 = add nuw nsw i64 %454, 2
%487 = add i64 %456, 2
%488 = icmp eq i64 %487, %440
br i1 %488, label %489, label %453
489: ; preds = %484, %433
%490 = phi i64 [ 1, %433 ], [ %486, %484 ]
%491 = phi i32 [ 0, %433 ], [ %485, %484 ]
%492 = icmp eq i64 %437, 0
br i1 %492, label %506, label %493
493: ; preds = %489
%494 = getelementptr inbounds i32, i32* %6, i64 %490
%495 = load i32, i32* %494
%496 = icmp eq i32 %495, 0
br i1 %496, label %506, label %497
497: ; preds = %493
%498 = getelementptr inbounds double, double* %4, i64 %490
%499 = load double, double* %498
%500 = add nsw i32 %491, 1
%501 = sext i32 %500 to i64
%502 = getelementptr inbounds double, double* %434, i64 %501
%503 = load double, double* %502
%504 = fadd double %499, %503
%505 = getelementptr inbounds double, double* %435, i64 %490
store double %504, double* %505
br label %506
506: ; preds = %493, %497, %489
%507 = icmp eq i32** %12, null
%508 = icmp eq double** %13, null
%509 = or i1 %507, %508
%510 = or i1 %509, %432
br i1 %510, label %511, label %513
511: ; preds = %431, %506
%512 = load double*, double** @mrqmin.atry
br label %549
513: ; preds = %506
%514 = load double*, double** @mrqmin.atry
%515 = add nuw i32 %5, 1
%516 = zext i32 %515 to i64
br label %517
517: ; preds = %513, %546
%518 = phi i64 [ 1, %513 ], [ %547, %546 ]
%519 = getelementptr inbounds i32*, i32** %12, i64 %518
%520 = load i32*, i32** %519
%521 = getelementptr inbounds i32, i32* %520, i64 1
%522 = load i32, i32* %521
%523 = icmp eq i32 %522, 0
br i1 %523, label %533, label %524
524: ; preds = %517
%525 = getelementptr inbounds double, double* %514, i64 %518
%526 = load double, double* %525
%527 = getelementptr inbounds double*, double** %13, i64 %518
%528 = load double*, double** %527
%529 = getelementptr inbounds double, double* %528, i64 1
%530 = load double, double* %529
%531 = fcmp olt double %526, %530
br i1 %531, label %532, label %533
532: ; preds = %524
store double %530, double* %525
br label %533
533: ; preds = %524, %532, %517
%534 = getelementptr inbounds i32, i32* %520, i64 2
%535 = load i32, i32* %534
%536 = icmp eq i32 %535, 0
br i1 %536, label %546, label %537
537: ; preds = %533
%538 = getelementptr inbounds double, double* %514, i64 %518
%539 = load double, double* %538
%540 = getelementptr inbounds double*, double** %13, i64 %518
%541 = load double*, double** %540
%542 = getelementptr inbounds double, double* %541, i64 2
%543 = load double, double* %542
%544 = fcmp ogt double %539, %543
br i1 %544, label %545, label %546
545: ; preds = %537
store double %543, double* %538
br label %546
546: ; preds = %533, %545, %537
%547 = add nuw nsw i64 %518, 1
%548 = icmp eq i64 %547, %516
br i1 %548, label %549, label %517
549: ; preds = %546, %511
%550 = phi double* [ %512, %511 ], [ %514, %546 ]
%551 = load double*, double** @mrqmin.da
%552 = tail call i32 @mrqcof(float* %0, float* %1, float* %2, i32 %3, double* %550, i32* %6, i32 %5, double** %7, double* %551, double* %9, void (float, double*, double*, double*, i32)* %10)
%553 = load double, double* %9
%554 = load double, double* @mrqmin.ochisq
%555 = fcmp olt double %553, %554
%556 = load double, double* %11
br i1 %555, label %557, label %843
557: ; preds = %549
%558 = fmul double %556, 1.000000e-01
store double %558, double* %11
%559 = load double, double* %9
store double %559, double* @mrqmin.ochisq
%560 = load i32, i32* @mrqmin.mfit
%561 = icmp slt i32 %560, 1
br i1 %561, label %683, label %562
562: ; preds = %557
%563 = load double*, double** @mrqmin.da
%564 = load double*, double** @mrqmin.beta
%565 = add nuw i32 %560, 1
%566 = zext i32 %565 to i64
%567 = add nsw i64 %566, -1
%568 = add nsw i64 %566, -5
%569 = lshr i64 %568, 2
%570 = add nuw nsw i64 %569, 1
%571 = icmp ult i64 %567, 4
%572 = and i64 %567, -4
%573 = or i64 %572, 1
%574 = and i64 %570, 3
%575 = icmp ult i64 %568, 12
%576 = and i64 %570, 9223372036854775804
%577 = icmp eq i64 %574, 0
%578 = icmp eq i64 %567, %572
br label %579
579: ; preds = %818, %562
%580 = phi i64 [ 1, %562 ], [ %822, %818 ]
%581 = getelementptr inbounds double*, double** %7, i64 %580
%582 = load double*, double** %581
%583 = getelementptr inbounds double*, double** %8, i64 %580
%584 = load double*, double** %583
br i1 %571, label %664, label %585
585: ; preds = %579
%586 = getelementptr double, double* %584, i64 1
%587 = getelementptr double, double* %584, i64 %566
%588 = getelementptr double, double* %582, i64 1
%589 = getelementptr double, double* %582, i64 %566
%590 = icmp ult double* %586, %589
%591 = icmp ult double* %588, %587
%592 = and i1 %590, %591
br i1 %592, label %664, label %593
593: ; preds = %585
br i1 %575, label %644, label %594
594: ; preds = %593, %594
%595 = phi i64 [ %641, %594 ], [ 0, %593 ]
%596 = phi i64 [ %642, %594 ], [ 0, %593 ]
%597 = or i64 %595, 1
%598 = getelementptr inbounds double, double* %582, i64 %597
%599 = bitcast double* %598 to <2 x double>*
%600 = load <2 x double>, <2 x double>* %599
%601 = getelementptr inbounds double, double* %598, i64 2
%602 = bitcast double* %601 to <2 x double>*
%603 = load <2 x double>, <2 x double>* %602
%604 = getelementptr inbounds double, double* %584, i64 %597
%605 = bitcast double* %604 to <2 x double>*
store <2 x double> %600, <2 x double>* %605
%606 = getelementptr inbounds double, double* %604, i64 2
%607 = bitcast double* %606 to <2 x double>*
store <2 x double> %603, <2 x double>* %607
%608 = or i64 %595, 5
%609 = getelementptr inbounds double, double* %582, i64 %608
%610 = bitcast double* %609 to <2 x double>*
%611 = load <2 x double>, <2 x double>* %610
%612 = getelementptr inbounds double, double* %609, i64 2
%613 = bitcast double* %612 to <2 x double>*
%614 = load <2 x double>, <2 x double>* %613
%615 = getelementptr inbounds double, double* %584, i64 %608
%616 = bitcast double* %615 to <2 x double>*
store <2 x double> %611, <2 x double>* %616
%617 = getelementptr inbounds double, double* %615, i64 2
%618 = bitcast double* %617 to <2 x double>*
store <2 x double> %614, <2 x double>* %618
%619 = or i64 %595, 9
%620 = getelementptr inbounds double, double* %582, i64 %619
%621 = bitcast double* %620 to <2 x double>*
%622 = load <2 x double>, <2 x double>* %621
%623 = getelementptr inbounds double, double* %620, i64 2
%624 = bitcast double* %623 to <2 x double>*
%625 = load <2 x double>, <2 x double>* %624
%626 = getelementptr inbounds double, double* %584, i64 %619
%627 = bitcast double* %626 to <2 x double>*
store <2 x double> %622, <2 x double>* %627
%628 = getelementptr inbounds double, double* %626, i64 2
%629 = bitcast double* %628 to <2 x double>*
store <2 x double> %625, <2 x double>* %629
%630 = or i64 %595, 13
%631 = getelementptr inbounds double, double* %582, i64 %630
%632 = bitcast double* %631 to <2 x double>*
%633 = load <2 x double>, <2 x double>* %632
%634 = getelementptr inbounds double, double* %631, i64 2
%635 = bitcast double* %634 to <2 x double>*
%636 = load <2 x double>, <2 x double>* %635
%637 = getelementptr inbounds double, double* %584, i64 %630
%638 = bitcast double* %637 to <2 x double>*
store <2 x double> %633, <2 x double>* %638
%639 = getelementptr inbounds double, double* %637, i64 2
%640 = bitcast double* %639 to <2 x double>*
store <2 x double> %636, <2 x double>* %640
%641 = add nuw i64 %595, 16
%642 = add nuw i64 %596, 4
%643 = icmp eq i64 %642, %576
br i1 %643, label %644, label %594
644: ; preds = %594, %593
%645 = phi i64 [ 0, %593 ], [ %641, %594 ]
br i1 %577, label %663, label %646
646: ; preds = %644, %646
%647 = phi i64 [ %660, %646 ], [ %645, %644 ]
%648 = phi i64 [ %661, %646 ], [ 0, %644 ]
%649 = or i64 %647, 1
%650 = getelementptr inbounds double, double* %582, i64 %649
%651 = bitcast double* %650 to <2 x double>*
%652 = load <2 x double>, <2 x double>* %651
%653 = getelementptr inbounds double, double* %650, i64 2
%654 = bitcast double* %653 to <2 x double>*
%655 = load <2 x double>, <2 x double>* %654
%656 = getelementptr inbounds double, double* %584, i64 %649
%657 = bitcast double* %656 to <2 x double>*
store <2 x double> %652, <2 x double>* %657
%658 = getelementptr inbounds double, double* %656, i64 2
%659 = bitcast double* %658 to <2 x double>*
store <2 x double> %655, <2 x double>* %659
%660 = add nuw i64 %647, 4
%661 = add i64 %648, 1
%662 = icmp eq i64 %661, %574
br i1 %662, label %663, label %646
663: ; preds = %646, %644
br i1 %578, label %818, label %664
664: ; preds = %585, %579, %663
%665 = phi i64 [ 1, %585 ], [ 1, %579 ], [ %573, %663 ]
%666 = sub nsw i64 %566, %665
%667 = xor i64 %665, -1
%668 = add nsw i64 %667, %566
%669 = and i64 %666, 3
%670 = icmp eq i64 %669, 0
br i1 %670, label %680, label %671
671: ; preds = %664, %671
%672 = phi i64 [ %677, %671 ], [ %665, %664 ]
%673 = phi i64 [ %678, %671 ], [ 0, %664 ]
%674 = getelementptr inbounds double, double* %582, i64 %672
%675 = load double, double* %674
%676 = getelementptr inbounds double, double* %584, i64 %672
store double %675, double* %676
%677 = add nuw nsw i64 %672, 1
%678 = add i64 %673, 1
%679 = icmp eq i64 %678, %669
br i1 %679, label %680, label %671
680: ; preds = %671, %664
%681 = phi i64 [ %665, %664 ], [ %677, %671 ]
%682 = icmp ult i64 %668, 3
br i1 %682, label %818, label %799
683: ; preds = %818, %557
br i1 %432, label %845, label %684
684: ; preds = %683
%685 = load double*, double** @mrqmin.atry
%686 = add nuw i32 %5, 1
%687 = zext i32 %686 to i64
%688 = add nsw i64 %687, -1
%689 = icmp ult i64 %688, 4
br i1 %689, label %780, label %690
690: ; preds = %684
%691 = getelementptr double, double* %4, i64 1
%692 = getelementptr double, double* %4, i64 %687
%693 = getelementptr double, double* %685, i64 1
%694 = getelementptr double, double* %685, i64 %687
%695 = icmp ult double* %691, %694
%696 = icmp ult double* %693, %692
%697 = and i1 %695, %696
br i1 %697, label %780, label %698
698: ; preds = %690
%699 = and i64 %688, -4
%700 = or i64 %699, 1
%701 = add nsw i64 %699, -4
%702 = lshr exact i64 %701, 2
%703 = add nuw nsw i64 %702, 1
%704 = and i64 %703, 3
%705 = icmp ult i64 %701, 12
br i1 %705, label %758, label %706
706: ; preds = %698
%707 = and i64 %703, 9223372036854775804
br label %708
708: ; preds = %708, %706
%709 = phi i64 [ 0, %706 ], [ %755, %708 ]
%710 = phi i64 [ 0, %706 ], [ %756, %708 ]
%711 = or i64 %709, 1
%712 = getelementptr inbounds double, double* %685, i64 %711
%713 = bitcast double* %712 to <2 x double>*
%714 = load <2 x double>, <2 x double>* %713
%715 = getelementptr inbounds double, double* %712, i64 2
%716 = bitcast double* %715 to <2 x double>*
%717 = load <2 x double>, <2 x double>* %716
%718 = getelementptr inbounds double, double* %4, i64 %711
%719 = bitcast double* %718 to <2 x double>*
store <2 x double> %714, <2 x double>* %719
%720 = getelementptr inbounds double, double* %718, i64 2
%721 = bitcast double* %720 to <2 x double>*
store <2 x double> %717, <2 x double>* %721
%722 = or i64 %709, 5
%723 = getelementptr inbounds double, double* %685, i64 %722
%724 = bitcast double* %723 to <2 x double>*
%725 = load <2 x double>, <2 x double>* %724
%726 = getelementptr inbounds double, double* %723, i64 2
%727 = bitcast double* %726 to <2 x double>*
%728 = load <2 x double>, <2 x double>* %727
%729 = getelementptr inbounds double, double* %4, i64 %722
%730 = bitcast double* %729 to <2 x double>*
store <2 x double> %725, <2 x double>* %730
%731 = getelementptr inbounds double, double* %729, i64 2
%732 = bitcast double* %731 to <2 x double>*
store <2 x double> %728, <2 x double>* %732
%733 = or i64 %709, 9
%734 = getelementptr inbounds double, double* %685, i64 %733
%735 = bitcast double* %734 to <2 x double>*
%736 = load <2 x double>, <2 x double>* %735
%737 = getelementptr inbounds double, double* %734, i64 2
%738 = bitcast double* %737 to <2 x double>*
%739 = load <2 x double>, <2 x double>* %738
%740 = getelementptr inbounds double, double* %4, i64 %733
%741 = bitcast double* %740 to <2 x double>*
store <2 x double> %736, <2 x double>* %741
%742 = getelementptr inbounds double, double* %740, i64 2
%743 = bitcast double* %742 to <2 x double>*
store <2 x double> %739, <2 x double>* %743
%744 = or i64 %709, 13
%745 = getelementptr inbounds double, double* %685, i64 %744
%746 = bitcast double* %745 to <2 x double>*
%747 = load <2 x double>, <2 x double>* %746
%748 = getelementptr inbounds double, double* %745, i64 2
%749 = bitcast double* %748 to <2 x double>*
%750 = load <2 x double>, <2 x double>* %749
%751 = getelementptr inbounds double, double* %4, i64 %744
%752 = bitcast double* %751 to <2 x double>*
store <2 x double> %747, <2 x double>* %752
%753 = getelementptr inbounds double, double* %751, i64 2
%754 = bitcast double* %753 to <2 x double>*
store <2 x double> %750, <2 x double>* %754
%755 = add nuw i64 %709, 16
%756 = add nuw i64 %710, 4
%757 = icmp eq i64 %756, %707
br i1 %757, label %758, label %708
758: ; preds = %708, %698
%759 = phi i64 [ 0, %698 ], [ %755, %708 ]
%760 = icmp eq i64 %704, 0
br i1 %760, label %778, label %761
761: ; preds = %758, %761
%762 = phi i64 [ %775, %761 ], [ %759, %758 ]
%763 = phi i64 [ %776, %761 ], [ 0, %758 ]
%764 = or i64 %762, 1
%765 = getelementptr inbounds double, double* %685, i64 %764
%766 = bitcast double* %765 to <2 x double>*
%767 = load <2 x double>, <2 x double>* %766
%768 = getelementptr inbounds double, double* %765, i64 2
%769 = bitcast double* %768 to <2 x double>*
%770 = load <2 x double>, <2 x double>* %769
%771 = getelementptr inbounds double, double* %4, i64 %764
%772 = bitcast double* %771 to <2 x double>*
store <2 x double> %767, <2 x double>* %772
%773 = getelementptr inbounds double, double* %771, i64 2
%774 = bitcast double* %773 to <2 x double>*
store <2 x double> %770, <2 x double>* %774
%775 = add nuw i64 %762, 4
%776 = add i64 %763, 1
%777 = icmp eq i64 %776, %704
br i1 %777, label %778, label %761
778: ; preds = %761, %758
%779 = icmp eq i64 %688, %699
br i1 %779, label %845, label %780
780: ; preds = %690, %684, %778
%781 = phi i64 [ 1, %690 ], [ 1, %684 ], [ %700, %778 ]
%782 = sub nsw i64 %687, %781
%783 = xor i64 %781, -1
%784 = add nsw i64 %783, %687
%785 = and i64 %782, 3
%786 = icmp eq i64 %785, 0
br i1 %786, label %796, label %787
787: ; preds = %780, %787
%788 = phi i64 [ %793, %787 ], [ %781, %780 ]
%789 = phi i64 [ %794, %787 ], [ 0, %780 ]
%790 = getelementptr inbounds double, double* %685, i64 %788
%791 = load double, double* %790
%792 = getelementptr inbounds double, double* %4, i64 %788
store double %791, double* %792
%793 = add nuw nsw i64 %788, 1
%794 = add i64 %789, 1
%795 = icmp eq i64 %794, %785
br i1 %795, label %796, label %787
796: ; preds = %787, %780
%797 = phi i64 [ %781, %780 ], [ %793, %787 ]
%798 = icmp ult i64 %784, 3
br i1 %798, label %845, label %824
799: ; preds = %680, %799
%800 = phi i64 [ %816, %799 ], [ %681, %680 ]
%801 = getelementptr inbounds double, double* %582, i64 %800
%802 = load double, double* %801
%803 = getelementptr inbounds double, double* %584, i64 %800
store double %802, double* %803
%804 = add nuw nsw i64 %800, 1
%805 = getelementptr inbounds double, double* %582, i64 %804
%806 = load double, double* %805
%807 = getelementptr inbounds double, double* %584, i64 %804
store double %806, double* %807
%808 = add nuw nsw i64 %800, 2
%809 = getelementptr inbounds double, double* %582, i64 %808
%810 = load double, double* %809
%811 = getelementptr inbounds double, double* %584, i64 %808
store double %810, double* %811
%812 = add nuw nsw i64 %800, 3
%813 = getelementptr inbounds double, double* %582, i64 %812
%814 = load double, double* %813
%815 = getelementptr inbounds double, double* %584, i64 %812
store double %814, double* %815
%816 = add nuw nsw i64 %800, 4
%817 = icmp eq i64 %816, %566
br i1 %817, label %818, label %799
818: ; preds = %680, %799, %663
%819 = getelementptr inbounds double, double* %563, i64 %580
%820 = load double, double* %819
%821 = getelementptr inbounds double, double* %564, i64 %580
store double %820, double* %821
%822 = add nuw nsw i64 %580, 1
%823 = icmp eq i64 %822, %566
br i1 %823, label %683, label %579
824: ; preds = %796, %824
%825 = phi i64 [ %841, %824 ], [ %797, %796 ]
%826 = getelementptr inbounds double, double* %685, i64 %825
%827 = load double, double* %826
%828 = getelementptr inbounds double, double* %4, i64 %825
store double %827, double* %828
%829 = add nuw nsw i64 %825, 1
%830 = getelementptr inbounds double, double* %685, i64 %829
%831 = load double, double* %830
%832 = getelementptr inbounds double, double* %4, i64 %829
store double %831, double* %832
%833 = add nuw nsw i64 %825, 2
%834 = getelementptr inbounds double, double* %685, i64 %833
%835 = load double, double* %834
%836 = getelementptr inbounds double, double* %4, i64 %833
store double %835, double* %836
%837 = add nuw nsw i64 %825, 3
%838 = getelementptr inbounds double, double* %685, i64 %837
%839 = load double, double* %838
%840 = getelementptr inbounds double, double* %4, i64 %837
store double %839, double* %840
%841 = add nuw nsw i64 %825, 4
%842 = icmp eq i64 %841, %687
br i1 %842, label %845, label %824
843: ; preds = %549
%844 = fmul double %556, 1.000000e+01
store double %844, double* %11
store double %554, double* %9
br label %845
845: ; preds = %796, %824, %778, %683, %843, %443
ret i32 %369
}