#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*/ free_matrix(float **, int, int, int, int);
int /*<<< orphan*/ free_vector(float *, int, int);
float **matrix(int, int, int, int);
float *vector(int, 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) {
  void covsrt(float **covar, int ma, int ia[], int mfit);
  void gaussj(float **a, int n, float **b, int m);
  void mrqcof(float x[], float y[], float sig[], int ndata, float a[], int ia[],
              int ma, float **alpha, float beta[], float *chisq,
              void (*funcs)(float, float[], float *, float[], int));
  int j, k, l;
  static int mfit;
  static float ochisq, *atry, *beta, *da, **oneda;
  if (*alamda < 0.0) {
    atry = vector(1, ma);
    beta = vector(1, ma);
    da = vector(1, ma);
    for (mfit = 0, j = 1; j <= ma; j++)
      if (ia[j])
        mfit++;
    oneda = matrix(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];
  }
  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);
    covsrt(alpha, ma, ia, mfit);
    free_matrix(oneda, 1, mfit, 1, 1);
    free_vector(da, 1, ma);
    free_vector(beta, 1, ma);
    free_vector(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 = 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;
  }
}


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   1080 <vector@plt>
mov    %rax,0x2e92(%rip)
mov    0x10(%rbp),%esi
mov    $0x1,%edi
call   1080 <vector@plt>
mov    %rax,0x2e86(%rip)
mov    0x10(%rbp),%esi
mov    $0x1,%edi
call   1080 <vector@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   1070 <matrix@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   1090 <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   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x2d38(%rip),%eax
jg     13fc <mrqmin+0x28c>
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    0x2d22(%rip),%eax
jg     137c <mrqmin+0x20c>
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)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1335 <mrqmin+0x1c5>
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  0xc6f(%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    0x2c9f(%rip),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x2c9f(%rip),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x4(%rax)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    131f <mrqmin+0x1af>
mov    0x18(%rbp),%rdi
mov    0x2c5a(%rip),%esi
mov    0x2c73(%rip),%rdx
mov    $0x1,%ecx
call   1050 <gaussj@plt>
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x2c39(%rip),%eax
jg     145f <mrqmin+0x2ef>
mov    0x2c4c(%rip),%rax
movslq -0x44(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x4(%rax),%xmm0
mov    0x2c30(%rip),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    141e <mrqmin+0x2ae>
mov    0x38(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    1509 <mrqmin+0x399>
jp     1509 <mrqmin+0x399>
mov    0x18(%rbp),%rdi
mov    0x10(%rbp),%esi
mov    -0x40(%rbp),%rdx
mov    0x2bd1(%rip),%ecx
call   1060 <covsrt@plt>
mov    0x20(%rbp),%rdi
mov    0x10(%rbp),%esi
mov    -0x40(%rbp),%rdx
mov    0x2bbb(%rip),%ecx
call   1060 <covsrt@plt>
mov    0x2bcf(%rip),%rdi
mov    0x2ba9(%rip),%edx
mov    $0x1,%r8d
mov    %r8d,%esi
mov    %r8d,%ecx
call   1030 <free_matrix@plt>
mov    0x2ba9(%rip),%rdi
mov    0x10(%rbp),%edx
mov    $0x1,%esi
call   1040 <free_vector@plt>
mov    0x2b8d(%rip),%rdi
mov    0x10(%rbp),%edx
mov    $0x1,%esi
call   1040 <free_vector@plt>
mov    0x2b71(%rip),%rdi
mov    0x10(%rbp),%edx
mov    $0x1,%esi
call   1040 <free_vector@plt>
jmp    1719 <mrqmin+0x5a9>
movl   $0x0,-0x44(%rbp)
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     157d <mrqmin+0x40d>
mov    -0x40(%rbp),%rax
movslq -0x4c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     156a <mrqmin+0x3fa>
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x2b2f(%rip),%rax
mov    -0x44(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x44(%rbp)
movslq %ecx,%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x2b07(%rip),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
jmp    156f <mrqmin+0x3ff>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1517 <mrqmin+0x3a7>
mov    -0x18(%rbp),%rdi
mov    -0x20(%rbp),%rsi
mov    -0x28(%rbp),%rdx
mov    -0x2c(%rbp),%ecx
mov    0x2ad5(%rip),%r8
mov    -0x40(%rbp),%r9
mov    0x10(%rbp),%r14d
mov    0x18(%rbp),%rbx
mov    0x2ad2(%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   1090 <mrqcof@plt>
mov    0x28(%rbp),%rax
movss  (%rax),%xmm1
movss  0x2a89(%rip),%xmm0
ucomiss %xmm1,%xmm0
jbe    16e9 <mrqmin+0x579>
mov    0x38(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0xa18(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    0x28(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,0x2a50(%rip)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x2a3c(%rip),%eax
jg     16a6 <mrqmin+0x536>
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    0x2a26(%rip),%eax
jg     1678 <mrqmin+0x508>
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)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1631 <mrqmin+0x4c1>
mov    0x29f9(%rip),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x29e1(%rip),%rax
movslq -0x44(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    161b <mrqmin+0x4ab>
movl   $0x1,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
cmp    0x10(%rbp),%eax
jg     16e4 <mrqmin+0x574>
mov    0x29a8(%rip),%rax
movslq -0x4c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x38(%rbp),%rax
movslq -0x4c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    16ad <mrqmin+0x53d>
jmp    1719 <mrqmin+0x5a9>
mov    0x38(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x90b(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax)
movss  0x2953(%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,0x8(%rsp)
mov    %r8,%r15
mov    %ecx,0x4(%rsp)
mov    %rdx,0x40(%rsp)
mov    %rsi,0x30(%rsp)
mov    %rdi,0x28(%rsp)
mov    0xc8(%rsp),%r13
mov    0xc0(%rsp),%rax
mov    %rax,0x38(%rsp)
mov    0xb8(%rsp),%r12
mov    0xb0(%rsp),%rbx
mov    0xa8(%rsp),%rax
mov    %rax,0x10(%rsp)
mov    0xa0(%rsp),%r14d
xorps  %xmm0,%xmm0
ucomiss 0x0(%r13),%xmm0
mov    %rbx,0x18(%rsp)
jbe    152b <mrqmin+0x3bb>
mov    $0x1,%edi
mov    %r14d,%esi
call   1080 <vector@plt>
mov    %rax,0x2e6e(%rip)
mov    $0x1,%edi
mov    %r14d,%esi
call   1080 <vector@plt>
mov    %rax,0x2e62(%rip)
mov    $0x1,%edi
mov    %r14d,%esi
call   1080 <vector@plt>
mov    %rax,0x2e56(%rip)
movl   $0x0,0x2e34(%rip)
test   %r14d,%r14d
jle    133c <mrqmin+0x1cc>
mov    %r14d,%ebp
cmp    $0x1,%r14d
jne    13ab <mrqmin+0x23b>
xor    %esi,%esi
mov    $0x1,%eax
mov    0x8(%rsp),%rdi
test   $0x1,%bpl
je     1263 <mrqmin+0xf3>
cmpl   $0x0,(%rdi,%rax,4)
je     1263 <mrqmin+0xf3>
add    $0x1,%esi
mov    %esi,0x2dfd(%rip)
mov    $0x1,%edi
mov    $0x1,%edx
mov    $0x1,%ecx
call   1070 <matrix@plt>
mov    %rax,0x2e02(%rip)
movl   $0x3a83126f,0x0(%r13)
3a
sub    $0x8,%rsp
mov    0x30(%rsp),%rdi
mov    0x38(%rsp),%rsi
mov    0x48(%rsp),%rdx
mov    0xc(%rsp),%ecx
mov    %r15,%r8
mov    0x10(%rsp),%r9
push   0x40(%rsp)
push   %r12
push   0x2dbf(%rip)
push   %rbx
push   %r14
call   1090 <mrqcof@plt>
add    $0x30,%rsp
movss  (%r12),%xmm0
movss  %xmm0,0x2d99(%rip)
test   %r14d,%r14d
jle    152b <mrqmin+0x3bb>
add    $0x1,%rbp
mov    0x2d89(%rip),%rax
lea    -0x1(%rbp),%rdx
mov    $0x1,%ecx
cmp    $0x8,%rdx
jb     14b8 <mrqmin+0x348>
lea    0x4(%rax),%rsi
lea    (%r15,%rbp,4),%rdi
cmp    %rdi,%rsi
jae    1310 <mrqmin+0x1a0>
lea    (%rax,%rbp,4),%rsi
lea    0x4(%r15),%rdi
cmp    %rsi,%rdi
jb     14b8 <mrqmin+0x348>
mov    %rdx,%rcx
and    $0xfffffffffffffff8,%rcx
lea    -0x8(%rcx),%rdi
mov    %rdi,%rsi
shr    $0x3,%rsi
add    $0x1,%rsi
mov    %esi,%ebx
and    $0x3,%ebx
cmp    $0x18,%rdi
jae    1407 <mrqmin+0x297>
xor    %edi,%edi
jmp    1472 <mrqmin+0x302>
mov    $0x1,%edi
xor    %esi,%esi
mov    $0x1,%edx
mov    $0x1,%ecx
call   1070 <matrix@plt>
mov    %rax,0x2d27(%rip)
movl   $0x3a83126f,0x0(%r13)
3a
sub    $0x8,%rsp
mov    0x30(%rsp),%rdi
mov    0x38(%rsp),%rsi
mov    0x48(%rsp),%rdx
mov    0xc(%rsp),%ecx
mov    %r15,%r8
mov    0x10(%rsp),%r9
push   0x40(%rsp)
push   %r12
push   0x2ce4(%rip)
push   %rbx
push   %r14
call   1090 <mrqcof@plt>
add    $0x30,%rsp
movss  (%r12),%xmm0
movss  %xmm0,0x2cbe(%rip)
jmp    152b <mrqmin+0x3bb>
mov    %ebp,%ecx
and    $0xfffffffe,%ecx
neg    %rcx
xor    %esi,%esi
mov    $0x1,%eax
mov    0x8(%rsp),%rdi
jmp    13e6 <mrqmin+0x276>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    (%rcx,%rax,1),%rdx
add    $0x2,%rdx
add    $0x2,%rax
cmp    $0x1,%rdx
je     124e <mrqmin+0xde>
cmpl   $0x0,(%rdi,%rax,4)
je     13f5 <mrqmin+0x285>
add    $0x1,%esi
mov    %esi,0x2c6b(%rip)
cmpl   $0x0,0x4(%rdi,%rax,4)
je     13d0 <mrqmin+0x260>
add    $0x1,%esi
mov    %esi,0x2c5b(%rip)
jmp    13d0 <mrqmin+0x260>
and    $0xfffffffffffffffc,%rsi
xor    %edi,%edi
nopl   (%rax)
movups 0x4(%r15,%rdi,4),%xmm0
movups 0x14(%r15,%rdi,4),%xmm1
movups %xmm0,0x4(%rax,%rdi,4)
movups %xmm1,0x14(%rax,%rdi,4)
movups 0x24(%r15,%rdi,4),%xmm0
movups 0x34(%r15,%rdi,4),%xmm1
movups %xmm0,0x24(%rax,%rdi,4)
movups %xmm1,0x34(%rax,%rdi,4)
movups 0x44(%r15,%rdi,4),%xmm0
movups 0x54(%r15,%rdi,4),%xmm1
movups %xmm0,0x44(%rax,%rdi,4)
movups %xmm1,0x54(%rax,%rdi,4)
movups 0x64(%r15,%rdi,4),%xmm0
movups 0x74(%r15,%rdi,4),%xmm1
movups %xmm0,0x64(%rax,%rdi,4)
movups %xmm1,0x74(%rax,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rsi
jne    1410 <mrqmin+0x2a0>
test   %rbx,%rbx
je     14aa <mrqmin+0x33a>
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rdi,4),%rsi
or     $0x4,%rsi
movups (%r15,%rsi,1),%xmm0
movups 0x10(%r15,%rsi,1),%xmm1
movups %xmm0,(%rax,%rsi,1)
movups %xmm1,0x10(%rax,%rsi,1)
add    $0x8,%rdi
add    $0xffffffffffffffff,%rbx
jne    1480 <mrqmin+0x310>
cmp    %rcx,%rdx
mov    0x18(%rsp),%rbx
je     152b <mrqmin+0x3bb>
or     $0x1,%rcx
mov    %ebp,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
not    %rdx
add    %rbp,%rdx
and    $0x3,%rsi
je     14e5 <mrqmin+0x375>
nopl   0x0(%rax,%rax,1)
movss  (%r15,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    14d0 <mrqmin+0x360>
cmp    $0x3,%rdx
jb     152b <mrqmin+0x3bb>
nopl   0x0(%rax,%rax,1)
movss  (%r15,%rcx,4),%xmm0
movss  %xmm0,(%rax,%rcx,4)
movss  0x4(%r15,%rcx,4),%xmm0
movss  %xmm0,0x4(%rax,%rcx,4)
movss  0x8(%r15,%rcx,4),%xmm0
movss  %xmm0,0x8(%rax,%rcx,4)
movss  0xc(%r15,%rcx,4),%xmm0
movss  %xmm0,0xc(%rax,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%rbp
jne    14f0 <mrqmin+0x380>
mov    0x2b2f(%rip),%esi
test   %esi,%esi
jle    17a2 <mrqmin+0x632>
mov    %r12,0x50(%rsp)
mov    %r14,0x20(%rsp)
mov    0x2b26(%rip),%r14
mov    0x2b2f(%rip),%rdx
lea    0x1(%rsi),%rcx
lea    -0x8(%rsi),%rax
mov    %rax,0x48(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %esi,%r11d
and    $0xfffffff8,%r11d
lea    0x1(%r11),%rdi
mov    %rdi,0x60(%rsp)
mov    %eax,%r10d
and    $0x3,%r10d
and    $0xfffffffffffffffc,%rax
mov    %rax,0x58(%rsp)
mov    $0x1,%r12d
movsd  0xa6c(%rip),%xmm0
jmp    15e9 <mrqmin+0x479>
cs nopw 0x0(%rax,%rax,1)
movss  0x0(%r13,%r12,4),%xmm1
cvtss2sd %xmm1,%xmm1
mov    %r8,%r13
movss  (%r8),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
movss  %xmm1,0x0(%rbp,%r12,4)
movss  (%r14,%r12,4),%xmm1
mov    (%rdx,%r12,8),%rax
movss  %xmm1,0x4(%rax)
add    $0x1,%r12
cmp    %rcx,%r12
je     1796 <mrqmin+0x626>
mov    %r13,%r8
mov    (%rbx,%r12,8),%r13
mov    0x10(%rsp),%rax
mov    (%rax,%r12,8),%rbp
mov    $0x1,%r9d
cmp    $0x8,%esi
jb     1700 <mrqmin+0x590>
lea    0x4(%rbp),%rax
lea    0x0(,%rcx,4),%rdi
add    %r13,%rdi
cmp    %rdi,%rax
jae    163a <mrqmin+0x4ca>
lea    0x0(,%rcx,4),%rax
add    %rbp,%rax
lea    0x4(%r13),%rdi
mov    $0x1,%r9d
cmp    %rax,%rdi
jb     1700 <mrqmin+0x590>
cmpq   $0x18,0x48(%rsp)
jae    1646 <mrqmin+0x4d6>
xor    %edi,%edi
jmp    16b2 <mrqmin+0x542>
mov    0x58(%rsp),%rax
xor    %edi,%edi
nopl   (%rax)
movups 0x4(%r13,%rdi,4),%xmm1
movups 0x14(%r13,%rdi,4),%xmm2
movups %xmm1,0x4(%rbp,%rdi,4)
movups %xmm2,0x14(%rbp,%rdi,4)
movups 0x24(%r13,%rdi,4),%xmm1
movups 0x34(%r13,%rdi,4),%xmm2
movups %xmm1,0x24(%rbp,%rdi,4)
movups %xmm2,0x34(%rbp,%rdi,4)
movups 0x44(%r13,%rdi,4),%xmm1
movups 0x54(%r13,%rdi,4),%xmm2
movups %xmm1,0x44(%rbp,%rdi,4)
movups %xmm2,0x54(%rbp,%rdi,4)
movups 0x64(%r13,%rdi,4),%xmm1
movups 0x74(%r13,%rdi,4),%xmm2
movups %xmm1,0x64(%rbp,%rdi,4)
movups %xmm2,0x74(%rbp,%rdi,4)
add    $0x20,%rdi
add    $0xfffffffffffffffc,%rax
jne    1650 <mrqmin+0x4e0>
test   %r10,%r10
je     16ec <mrqmin+0x57c>
mov    %r10,%rax
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rdi,4),%rbx
or     $0x4,%rbx
movups 0x0(%r13,%rbx,1),%xmm1
movups 0x10(%r13,%rbx,1),%xmm2
movups %xmm1,0x0(%rbp,%rbx,1)
movups %xmm2,0x10(%rbp,%rbx,1)
add    $0x8,%rdi
add    $0xffffffffffffffff,%rax
jne    16c0 <mrqmin+0x550>
mov    0x60(%rsp),%r9
cmp    %r11,%rsi
mov    0x18(%rsp),%rbx
je     15a0 <mrqmin+0x430>
nop
mov    %ecx,%edi
sub    %r9d,%edi
mov    %r9,%rax
not    %rax
add    %rcx,%rax
and    $0x3,%rdi
je     1738 <mrqmin+0x5c8>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  0x0(%r13,%r9,4),%xmm1
movss  %xmm1,0x0(%rbp,%r9,4)
add    $0x1,%r9
add    $0xffffffffffffffff,%rdi
jne    1720 <mrqmin+0x5b0>
cmp    $0x3,%rax
jb     15a0 <mrqmin+0x430>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movss  0x0(%r13,%r9,4),%xmm1
movss  %xmm1,0x0(%rbp,%r9,4)
movss  0x4(%r13,%r9,4),%xmm1
movss  %xmm1,0x4(%rbp,%r9,4)
movss  0x8(%r13,%r9,4),%xmm1
movss  %xmm1,0x8(%rbp,%r9,4)
movss  0xc(%r13,%r9,4),%xmm1
movss  %xmm1,0xc(%rbp,%r9,4)
add    $0x4,%r9
cmp    %r9,%rcx
jne    1750 <mrqmin+0x5e0>
jmp    15a0 <mrqmin+0x430>
mov    0x20(%rsp),%r14
mov    0x50(%rsp),%r12
jmp    17a9 <mrqmin+0x639>
mov    0x28d7(%rip),%rdx
mov    0x10(%rsp),%rdi
mov    $0x1,%ecx
call   1050 <gaussj@plt>
mov    0x28a2(%rip),%ecx
test   %ecx,%ecx
mov    0x8(%rsp),%r9
jle    1887 <mrqmin+0x717>
mov    0x28ae(%rip),%rdx
mov    0x289f(%rip),%rsi
lea    -0x1(%rcx),%rbp
mov    %ecx,%eax
and    $0x3,%eax
mov    $0x1,%edi
cmp    $0x3,%rbp
jb     1852 <mrqmin+0x6e2>
mov    %ecx,%ebp
and    $0xfffffffc,%ebp
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
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    1800 <mrqmin+0x690>
add    $0x1,%rdi
mov    0x18(%rsp),%rbx
test   %rax,%rax
je     1887 <mrqmin+0x717>
lea    (%rsi,%rdi,4),%rsi
lea    (%rdx,%rdi,8),%rdx
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    (%rdx,%rdi,8),%rbp
movss  0x4(%rbp),%xmm0
movss  %xmm0,(%rsi,%rdi,4)
add    $0x1,%rdi
cmp    %rdi,%rax
jne    1870 <mrqmin+0x700>
movss  0x0(%r13),%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1932 <mrqmin+0x7c2>
jp     1932 <mrqmin+0x7c2>
mov    0x10(%rsp),%rdi
mov    %r14d,%esi
mov    %r9,%rdx
mov    %r9,%rbp
call   1060 <covsrt@plt>
mov    0x27a8(%rip),%ecx
mov    %rbx,%rdi
mov    %r14d,%esi
mov    %rbp,%rdx
call   1060 <covsrt@plt>
mov    0x27b3(%rip),%rdi
mov    0x278d(%rip),%edx
mov    $0x1,%esi
mov    $0x1,%ecx
mov    $0x1,%r8d
call   1030 <free_matrix@plt>
mov    0x2789(%rip),%rdi
mov    $0x1,%esi
mov    %r14d,%edx
call   1040 <free_vector@plt>
mov    0x276d(%rip),%rdi
mov    $0x1,%esi
mov    %r14d,%edx
call   1040 <free_vector@plt>
mov    0x2751(%rip),%rdi
mov    $0x1,%esi
mov    %r14d,%edx
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1040 <free_vector@plt>
test   %r14d,%r14d
jle    197c <mrqmin+0x80c>
mov    0x273a(%rip),%rax
mov    0x2723(%rip),%r8
mov    %r14d,%ecx
cmp    $0x1,%r14d
jne    1c71 <mrqmin+0xb01>
xor    %esi,%esi
mov    $0x1,%edx
test   $0x1,%cl
je     198a <mrqmin+0x81a>
cmpl   $0x0,(%r9,%rdx,4)
je     198a <mrqmin+0x81a>
movss  (%r15,%rdx,4),%xmm0
movslq %esi,%rcx
addss  0x4(%rax,%rcx,4),%xmm0
movss  %xmm0,(%r8,%rdx,4)
jmp    198a <mrqmin+0x81a>
mov    0x26e5(%rip),%r8
mov    0x26ee(%rip),%rax
sub    $0x8,%rsp
mov    0x30(%rsp),%rdi
mov    0x38(%rsp),%rsi
mov    0x48(%rsp),%rdx
mov    0xc(%rsp),%ecx
push   0x40(%rsp)
push   %r12
push   %rax
push   0x30(%rsp)
push   %r14
call   1090 <mrqcof@plt>
add    $0x30,%rsp
movss  0x26a5(%rip),%xmm0
ucomiss (%r12),%xmm0
movss  0x0(%r13),%xmm1
jbe    1bec <mrqmin+0xa7c>
mov    %r14,0x20(%rsp)
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
mulsd  0x624(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,0x0(%r13)
movss  (%r12),%xmm0
movss  %xmm0,0x2668(%rip)
mov    0x265e(%rip),%eax
test   %eax,%eax
jle    1c05 <mrqmin+0xa95>
mov    0x2667(%rip),%r12
mov    0x2658(%rip),%r13
lea    0x1(%rax),%r8
lea    -0x8(%rax),%r9
mov    %r9,%r10
shr    $0x3,%r10
add    $0x1,%r10
mov    %eax,%r11d
and    $0xfffffff8,%r11d
lea    0x1(%r11),%rcx
mov    %rcx,0x48(%rsp)
mov    %r10d,%r14d
and    $0x3,%r14d
and    $0xfffffffffffffffc,%r10
mov    $0x1,%ebp
jmp    1a6a <mrqmin+0x8fa>
nopl   (%rax)
movss  (%r12,%rbp,4),%xmm0
movss  %xmm0,0x0(%r13,%rbp,4)
add    $0x1,%rbp
cmp    %r8,%rbp
je     1c05 <mrqmin+0xa95>
mov    0x10(%rsp),%rcx
mov    (%rcx,%rbp,8),%rbx
mov    0x18(%rsp),%rcx
mov    (%rcx,%rbp,8),%rdi
mov    $0x1,%ecx
cmp    $0x8,%eax
jb     1b70 <mrqmin+0xa00>
lea    0x4(%rdi),%rcx
lea    (%rbx,%r8,4),%rdx
cmp    %rdx,%rcx
jae    1aad <mrqmin+0x93d>
lea    (%rdi,%r8,4),%rdx
lea    0x4(%rbx),%rsi
mov    $0x1,%ecx
cmp    %rdx,%rsi
jb     1b70 <mrqmin+0xa00>
cmp    $0x18,%r9
jae    1ab7 <mrqmin+0x947>
xor    %ecx,%ecx
jmp    1b1a <mrqmin+0x9aa>
mov    %r10,%rdx
xor    %ecx,%ecx
nopl   0x0(%rax)
movups 0x4(%rbx,%rcx,4),%xmm0
movups 0x14(%rbx,%rcx,4),%xmm1
movups %xmm0,0x4(%rdi,%rcx,4)
movups %xmm1,0x14(%rdi,%rcx,4)
movups 0x24(%rbx,%rcx,4),%xmm0
movups 0x34(%rbx,%rcx,4),%xmm1
movups %xmm0,0x24(%rdi,%rcx,4)
movups %xmm1,0x34(%rdi,%rcx,4)
movups 0x44(%rbx,%rcx,4),%xmm0
movups 0x54(%rbx,%rcx,4),%xmm1
movups %xmm0,0x44(%rdi,%rcx,4)
movups %xmm1,0x54(%rdi,%rcx,4)
movups 0x64(%rbx,%rcx,4),%xmm0
movups 0x74(%rbx,%rcx,4),%xmm1
movups %xmm0,0x64(%rdi,%rcx,4)
movups %xmm1,0x74(%rdi,%rcx,4)
add    $0x20,%rcx
add    $0xfffffffffffffffc,%rdx
jne    1ac0 <mrqmin+0x950>
test   %r14,%r14
je     1b58 <mrqmin+0x9e8>
mov    %r14,%rdx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x0(,%rcx,4),%rsi
or     $0x4,%rsi
movups (%rbx,%rsi,1),%xmm0
movups 0x10(%rbx,%rsi,1),%xmm1
movups %xmm0,(%rdi,%rsi,1)
movups %xmm1,0x10(%rdi,%rsi,1)
add    $0x8,%rcx
add    $0xffffffffffffffff,%rdx
jne    1b30 <mrqmin+0x9c0>
mov    0x48(%rsp),%rcx
cmp    %r11,%rax
je     1a50 <mrqmin+0x8e0>
cs nopw 0x0(%rax,%rax,1)
mov    %r8d,%esi
sub    %ecx,%esi
mov    %rcx,%rdx
not    %rdx
add    %r8,%rdx
and    $0x3,%rsi
je     1ba4 <mrqmin+0xa34>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rdi,%rcx,4)
add    $0x1,%rcx
add    $0xffffffffffffffff,%rsi
jne    1b90 <mrqmin+0xa20>
cmp    $0x3,%rdx
jb     1a50 <mrqmin+0x8e0>
xchg   %ax,%ax
movss  (%rbx,%rcx,4),%xmm0
movss  %xmm0,(%rdi,%rcx,4)
movss  0x4(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x4(%rdi,%rcx,4)
movss  0x8(%rbx,%rcx,4),%xmm0
movss  %xmm0,0x8(%rdi,%rcx,4)
movss  0xc(%rbx,%rcx,4),%xmm0
movss  %xmm0,0xc(%rdi,%rcx,4)
add    $0x4,%rcx
cmp    %rcx,%r8
jne    1bb0 <mrqmin+0xa40>
jmp    1a50 <mrqmin+0x8e0>
mulss  0x41c(%rip),%xmm1
movss  %xmm1,0x0(%r13)
movss  %xmm0,(%r12)
jmp    1e0b <mrqmin+0xc9b>
mov    0x20(%rsp),%rdi
test   %edi,%edi
jle    1e0b <mrqmin+0xc9b>
mov    0x244f(%rip),%rax
mov    %edi,%esi
lea    0x1(%rsi),%rcx
mov    $0x1,%edx
cmp    $0x8,%edi
jb     1d93 <mrqmin+0xc23>
lea    0x4(%r15),%rdi
lea    (%rax,%rcx,4),%rbp
cmp    %rbp,%rdi
jae    1c4b <mrqmin+0xadb>
lea    (%r15,%rcx,4),%rdi
lea    0x4(%rax),%rbp
cmp    %rdi,%rbp
jb     1d93 <mrqmin+0xc23>
mov    %esi,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rbp
mov    %rbp,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%ebx
and    $0x3,%ebx
cmp    $0x18,%rbp
jae    1ce9 <mrqmin+0xb79>
xor    %ebp,%ebp
jmp    1d52 <mrqmin+0xbe2>
mov    %ecx,%edi
and    $0xfffffffe,%edi
neg    %rdi
xor    %esi,%esi
mov    $0x1,%edx
jmp    1ca6 <mrqmin+0xb36>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    (%rdi,%rdx,1),%rbp
add    $0x2,%rbp
add    $0x2,%rdx
cmp    $0x1,%rbp
je     1959 <mrqmin+0x7e9>
cmpl   $0x0,(%r9,%rdx,4)
je     1cc5 <mrqmin+0xb55>
movss  (%r15,%rdx,4),%xmm0
movslq %esi,%rbp
add    $0x1,%esi
addss  0x4(%rax,%rbp,4),%xmm0
movss  %xmm0,(%r8,%rdx,4)
cmpl   $0x0,0x4(%r9,%rdx,4)
je     1c90 <mrqmin+0xb20>
movss  0x4(%r15,%rdx,4),%xmm0
movslq %esi,%rbp
add    $0x1,%esi
addss  0x4(%rax,%rbp,4),%xmm0
movss  %xmm0,0x4(%r8,%rdx,4)
jmp    1c90 <mrqmin+0xb20>
and    $0xfffffffffffffffc,%rdi
xor    %ebp,%ebp
nop
movups 0x4(%rax,%rbp,4),%xmm0
movups 0x14(%rax,%rbp,4),%xmm1
movups %xmm0,0x4(%r15,%rbp,4)
movups %xmm1,0x14(%r15,%rbp,4)
movups 0x24(%rax,%rbp,4),%xmm0
movups 0x34(%rax,%rbp,4),%xmm1
movups %xmm0,0x24(%r15,%rbp,4)
movups %xmm1,0x34(%r15,%rbp,4)
movups 0x44(%rax,%rbp,4),%xmm0
movups 0x54(%rax,%rbp,4),%xmm1
movups %xmm0,0x44(%r15,%rbp,4)
movups %xmm1,0x54(%r15,%rbp,4)
movups 0x64(%rax,%rbp,4),%xmm0
movups 0x74(%rax,%rbp,4),%xmm1
movups %xmm0,0x64(%r15,%rbp,4)
movups %xmm1,0x74(%r15,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    1cf0 <mrqmin+0xb80>
test   %rbx,%rbx
je     1d8a <mrqmin+0xc1a>
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rbp,4),%rdi
or     $0x4,%rdi
movups (%rax,%rdi,1),%xmm0
movups 0x10(%rax,%rdi,1),%xmm1
movups %xmm0,(%r15,%rdi,1)
movups %xmm1,0x10(%r15,%rdi,1)
add    $0x8,%rbp
add    $0xffffffffffffffff,%rbx
jne    1d60 <mrqmin+0xbf0>
cmp    %rdx,%rsi
je     1e0b <mrqmin+0xc9b>
or     $0x1,%rdx
mov    %ecx,%edi
sub    %edx,%edi
mov    %rdx,%rsi
not    %rsi
add    %rcx,%rsi
and    $0x3,%rdi
je     1dc5 <mrqmin+0xc55>
cs nopw 0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm0
movss  %xmm0,(%r15,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    1db0 <mrqmin+0xc40>
cmp    $0x3,%rsi
jb     1e0b <mrqmin+0xc9b>
nopl   0x0(%rax,%rax,1)
movss  (%rax,%rdx,4),%xmm0
movss  %xmm0,(%r15,%rdx,4)
movss  0x4(%rax,%rdx,4),%xmm0
movss  %xmm0,0x4(%r15,%rdx,4)
movss  0x8(%rax,%rdx,4),%xmm0
movss  %xmm0,0x8(%r15,%rdx,4)
movss  0xc(%rax,%rdx,4),%xmm0
movss  %xmm0,0xc(%r15,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    1dd0 <mrqmin+0xc60>
add    $0x68,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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