int mrqmin(x, y, sig, ndata, a, ma, lista, mfit, covar, alpha, chisq, funcs,
           alamda)
float x[], y[], sig[], a[], **covar, **alpha, *chisq, *alamda;
int ndata, ma, lista[], mfit;
void (*funcs)();
{
  int k, kk, j, ihit;
  static float *da, *atry, **oneda, *beta, ochisq;
  float *vector(), **matrix();
  void mrqcof(), covsrt(), nrerror(), free_matrix(), free_vector();
  int gaussj();
  if (*alamda < 0.0) {
    oneda = matrix(1, mfit, 1, 1);
    atry = vector(1, ma);
    da = vector(1, ma);
    beta = vector(1, ma);
    kk = mfit + 1;
    for (j = 1; j <= ma; j++) {
      ihit = 0;
      for (k = 1; k <= mfit; k++)
        if (lista[k] == j)
          ihit++;
      if (ihit == 0) {
        lista[kk++] = j;
      } else if (ihit > 1) {
        nrerror("Bad LISTA permutation in MRQMIN-1");
        return (0);
      }
    }
    if (kk != ma + 1) {
      nrerror("Bad LISTA permutation in MRQMIN-2");
      return (0);
    }
    *alamda = 0.001;
    mrqcof(x, y, sig, ndata, a, ma, lista, mfit, alpha, beta, chisq, funcs);
    ochisq = (*chisq);
  }
  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];
  }
  if (gaussj(covar, mfit, oneda, 1) == 0)
    return (0);
  for (j = 1; j <= mfit; j++)
    da[j] = oneda[j][1];
  if (*alamda == 0.0) {
    covsrt(covar, ma, lista, mfit);
    free_vector(beta, 1, ma);
    free_vector(da, 1, ma);
    free_vector(atry, 1, ma);
    free_matrix(oneda, 1, mfit, 1, 1);
    return (1);
  }
  for (j = 1; j <= ma; j++)
    atry[j] = a[j];
  for (j = 1; j <= mfit; j++)
    atry[lista[j]] = a[lista[j]] + da[j];
  mrqcof(x, y, sig, ndata, atry, ma, lista, mfit, 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];
      a[lista[j]] = atry[lista[j]];
    }
  } else {
    *alamda *= 10.0;
    *chisq = ochisq;
  }
  return (1);
}


x86 assembly (clang, -O0):
<mrqmin>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %rbx
sub    $0x78,%rsp
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%eax
mov    0x10(%rbp),%rax
mov    %rdi,-0x28(%rbp)
mov    %rsi,-0x30(%rbp)
mov    %rdx,-0x38(%rbp)
mov    %ecx,-0x3c(%rbp)
mov    %r8,-0x48(%rbp)
mov    %r9d,-0x4c(%rbp)
mov    0x40(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm1
xorps  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    139e <mrqmin+0x21e>
mov    0x18(%rbp),%esi
mov    $0x1,%ecx
mov    %ecx,%edi
mov    %ecx,%edx
mov    $0x0,%al
call   1080 <matrix@plt>
mov    %rax,0x2e86(%rip)
mov    -0x4c(%rbp),%esi
mov    $0x1,%edi
mov    $0x0,%al
call   1090 <vector@plt>
mov    %rax,0x2e68(%rip)
mov    -0x4c(%rbp),%esi
mov    $0x1,%edi
mov    $0x0,%al
call   1090 <vector@plt>
mov    %rax,0x2e4a(%rip)
mov    -0x4c(%rbp),%esi
mov    $0x1,%edi
mov    $0x0,%al
call   1090 <vector@plt>
mov    %rax,0x2e4c(%rip)
mov    0x18(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     12fd <mrqmin+0x17d>
movl   $0x0,-0x5c(%rbp)
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     129a <mrqmin+0x11a>
mov    0x10(%rbp),%rax
movslq -0x50(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
cmp    -0x58(%rbp),%eax
jne    1287 <mrqmin+0x107>
mov    -0x5c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
jmp    128c <mrqmin+0x10c>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    125e <mrqmin+0xde>
cmpl   $0x0,-0x5c(%rbp)
jne    12c1 <mrqmin+0x141>
mov    -0x58(%rbp),%edx
mov    0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x54(%rbp)
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
jmp    12ea <mrqmin+0x16a>
cmpl   $0x1,-0x5c(%rbp)
jle    12e5 <mrqmin+0x165>
lea    0xd4e(%rip),%rdi
mov    $0x0,%al
call   1040 <nrerror@plt>
movl   $0x0,-0x1c(%rbp)
jmp    17c2 <mrqmin+0x642>
jmp    12ea <mrqmin+0x16a>
jmp    12ef <mrqmin+0x16f>
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1244 <mrqmin+0xc4>
mov    -0x54(%rbp),%eax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
je     1328 <mrqmin+0x1a8>
lea    0xd2d(%rip),%rdi
mov    $0x0,%al
call   1040 <nrerror@plt>
movl   $0x0,-0x1c(%rbp)
jmp    17c2 <mrqmin+0x642>
mov    0x40(%rbp),%rax
movss  0xccc(%rip),%xmm0
movss  %xmm0,(%rax)
mov    -0x28(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x38(%rbp),%rdx
mov    -0x3c(%rbp),%ecx
mov    -0x48(%rbp),%r8
mov    -0x4c(%rbp),%r9d
mov    0x10(%rbp),%r15
mov    0x18(%rbp),%r14d
mov    0x28(%rbp),%rbx
mov    0x2d1e(%rip),%r11
mov    0x30(%rbp),%r10
mov    0x38(%rbp),%rax
mov    %r15,(%rsp)
mov    %r14d,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
mov    $0x0,%al
call   10a0 <mrqcof@plt>
mov    0x30(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,0x2cea(%rip)
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     147c <mrqmin+0x2fc>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     13fc <mrqmin+0x27c>
mov    0x28(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    13b8 <mrqmin+0x238>
mov    0x28(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm0
mov    0x40(%rbp),%rax
movss  (%rax),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0xbef(%rip),%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x2c2f(%rip),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x2c17(%rip),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  %xmm0,0x4(%rax)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    13a5 <mrqmin+0x225>
mov    0x20(%rbp),%rdi
mov    0x18(%rbp),%esi
mov    0x2bee(%rip),%rdx
mov    $0x1,%ecx
mov    $0x0,%al
call   1060 <gaussj@plt>
cmp    $0x0,%eax
jne    14ab <mrqmin+0x32b>
movl   $0x0,-0x1c(%rbp)
jmp    17c2 <mrqmin+0x642>
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     14f0 <mrqmin+0x370>
mov    0x2bb3(%rip),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movss  0x4(%rax),%xmm0
mov    0x2b8f(%rip),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    14b2 <mrqmin+0x332>
mov    0x40(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jne    158f <mrqmin+0x40f>
jp     158f <mrqmin+0x40f>
mov    0x20(%rbp),%rdi
mov    -0x4c(%rbp),%esi
mov    0x10(%rbp),%rdx
mov    0x18(%rbp),%ecx
mov    $0x0,%al
call   1070 <covsrt@plt>
mov    0x2b55(%rip),%rdi
mov    -0x4c(%rbp),%edx
mov    $0x1,%esi
mov    $0x0,%al
call   1050 <free_vector@plt>
mov    0x2b27(%rip),%rdi
mov    -0x4c(%rbp),%edx
mov    $0x1,%esi
mov    $0x0,%al
call   1050 <free_vector@plt>
mov    0x2b19(%rip),%rdi
mov    -0x4c(%rbp),%edx
mov    $0x1,%esi
mov    $0x0,%al
call   1050 <free_vector@plt>
mov    0x2b0b(%rip),%rdi
mov    0x18(%rbp),%edx
mov    $0x1,%r8d
mov    %r8d,%esi
mov    %r8d,%ecx
mov    $0x0,%al
call   1030 <free_matrix@plt>
movl   $0x1,-0x1c(%rbp)
jmp    17c2 <mrqmin+0x642>
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     15cd <mrqmin+0x44d>
mov    -0x48(%rbp),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x2aba(%rip),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    1596 <mrqmin+0x416>
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     162b <mrqmin+0x4ab>
mov    -0x48(%rbp),%rax
mov    0x10(%rbp),%rcx
movslq -0x58(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x2a6c(%rip),%rax
movslq -0x58(%rbp),%rcx
addss  (%rax,%rcx,4),%xmm0
mov    0x2a64(%rip),%rax
mov    0x10(%rbp),%rcx
movslq -0x58(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    15d4 <mrqmin+0x454>
mov    -0x28(%rbp),%rdi
mov    -0x30(%rbp),%rsi
mov    -0x38(%rbp),%rdx
mov    -0x3c(%rbp),%ecx
mov    0x2a2f(%rip),%r8
mov    -0x4c(%rbp),%r9d
mov    0x10(%rbp),%r15
mov    0x18(%rbp),%r14d
mov    0x20(%rbp),%rbx
mov    0x2a10(%rip),%r11
mov    0x30(%rbp),%r10
mov    0x38(%rbp),%rax
mov    %r15,(%rsp)
mov    %r14d,0x8(%rsp)
mov    %rbx,0x10(%rsp)
mov    %r11,0x18(%rsp)
mov    %r10,0x20(%rsp)
mov    %rax,0x28(%rsp)
mov    $0x0,%al
call   10a0 <mrqcof@plt>
mov    0x30(%rbp),%rax
movss  (%rax),%xmm1
movss  0x29f4(%rip),%xmm0
ucomiss %xmm1,%xmm0
jbe    178b <mrqmin+0x60b>
mov    0x40(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x95f(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax)
mov    0x30(%rbp),%rax
movss  (%rax),%xmm0
movss  %xmm0,0x29bb(%rip)
movl   $0x1,-0x58(%rbp)
mov    -0x58(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     1786 <mrqmin+0x606>
movl   $0x1,-0x50(%rbp)
mov    -0x50(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     172b <mrqmin+0x5ab>
mov    0x20(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x28(%rbp),%rax
movslq -0x58(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x50(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    16e7 <mrqmin+0x567>
mov    0x2936(%rip),%rax
movslq -0x58(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x293e(%rip),%rax
movslq -0x58(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    0x291e(%rip),%rax
mov    0x10(%rbp),%rcx
movslq -0x58(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x48(%rbp),%rax
mov    0x10(%rbp),%rcx
movslq -0x58(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x58(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
jmp    16d4 <mrqmin+0x554>
jmp    17bb <mrqmin+0x63b>
mov    0x40(%rbp),%rax
movss  (%rax),%xmm0
cvtss2sd %xmm0,%xmm0
movsd  0x869(%rip),%xmm1
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax)
movss  0x28d5(%rip),%xmm0
mov    0x30(%rbp),%rax
movss  %xmm0,(%rax)
movl   $0x1,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x78,%rsp
pop    %rbx
pop    %r14
pop    %r15
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,%r14d
mov    %r8,%r13
mov    %ecx,0xc(%rsp)
mov    %rdx,0x38(%rsp)
mov    %rsi,0x30(%rsp)
mov    %rdi,0x28(%rsp)
mov    0xb0(%rsp),%rbp
mov    0x98(%rsp),%r12
mov    0x88(%rsp),%esi
mov    0x80(%rsp),%rbx
xorps  %xmm0,%xmm0
ucomiss 0x0(%rbp),%xmm0
mov    %r14,(%rsp)
jbe    1437 <mrqmin+0x2b7>
mov    $0x1,%ebp
mov    $0x1,%edi
mov    0x88(%rsp),%esi
mov    $0x1,%edx
mov    $0x1,%ecx
xor    %eax,%eax
call   1080 <matrix@plt>
mov    %rax,0x2e78(%rip)
mov    $0x1,%edi
mov    %r14d,%esi
xor    %eax,%eax
call   1090 <vector@plt>
mov    %rax,0x2e5a(%rip)
mov    $0x1,%edi
mov    %r14d,%esi
xor    %eax,%eax
call   1090 <vector@plt>
mov    %rax,0x2e3c(%rip)
mov    $0x1,%edi
mov    %r14d,%esi
xor    %eax,%eax
call   1090 <vector@plt>
mov    0x88(%rsp),%esi
mov    %rax,%r10
mov    %rax,0x2e34(%rip)
lea    0x1(%rsi),%eax
test   %r14d,%r14d
mov    %r14,%rdi
jle    13bc <mrqmin+0x23c>
mov    %eax,%ecx
lea    -0x1(%rcx),%r12
lea    -0x9(%rcx),%r8
mov    %r8,%r14
shr    $0x3,%r14
add    $0x1,%r14
mov    %r12,%r15
and    $0xfffffffffffffff8,%r15
lea    0x1(%r15),%r9
movabs $0x3ffffffffffffffc,%r11
ff ff 3f
or     $0x2,%r11
and    %r14,%r11
jmp    12b9 <mrqmin+0x139>
xchg   %ax,%ax
test   %esi,%esi
mov    0x88(%rsp),%esi
mov    (%rsp),%rdi
jne    18d2 <mrqmin+0x752>
movslq %eax,%rdx
add    $0x1,%eax
mov    %ebp,(%rbx,%rdx,4)
lea    0x1(%rbp),%edx
cmp    %edi,%ebp
mov    %edx,%ebp
je     13bc <mrqmin+0x23c>
test   %esi,%esi
jle    12a3 <mrqmin+0x123>
cmp    $0x8,%r12
jae    12d0 <mrqmin+0x150>
xor    %esi,%esi
mov    $0x1,%edi
jmp    1390 <mrqmin+0x210>
nop
movd   %ebp,%xmm0
pshufd $0x0,%xmm0,%xmm1
pxor   %xmm0,%xmm0
cmp    $0x8,%r8
jae    12eb <mrqmin+0x16b>
xor    %esi,%esi
pxor   %xmm2,%xmm2
jmp    1342 <mrqmin+0x1c2>
mov    %r11,%rdi
xor    %esi,%esi
pxor   %xmm2,%xmm2
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movdqu 0x4(%rbx,%rsi,4),%xmm3
movdqu 0x14(%rbx,%rsi,4),%xmm4
movdqu 0x24(%rbx,%rsi,4),%xmm5
movdqu 0x34(%rbx,%rsi,4),%xmm6
pcmpeqd %xmm1,%xmm3
psubd  %xmm3,%xmm0
pcmpeqd %xmm1,%xmm4
psubd  %xmm4,%xmm2
pcmpeqd %xmm1,%xmm5
psubd  %xmm5,%xmm0
pcmpeqd %xmm1,%xmm6
psubd  %xmm6,%xmm2
add    $0x10,%rsi
add    $0xfffffffffffffffe,%rdi
jne    1300 <mrqmin+0x180>
test   $0x1,%r14b
je     136b <mrqmin+0x1eb>
shl    $0x2,%rsi
or     $0x4,%rsi
movdqu (%rbx,%rsi,1),%xmm3
movdqu 0x10(%rbx,%rsi,1),%xmm4
pcmpeqd %xmm1,%xmm3
psubd  %xmm3,%xmm0
pcmpeqd %xmm1,%xmm4
psubd  %xmm4,%xmm2
paddd  %xmm2,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%esi
mov    %r9,%rdi
cmp    %r15,%r12
je     13a3 <mrqmin+0x223>
nopl   (%rax)
xor    %edx,%edx
cmp    %ebp,(%rbx,%rdi,4)
sete   %dl
add    %edx,%esi
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    1390 <mrqmin+0x210>
cmp    $0x1,%esi
jne    1290 <mrqmin+0x110>
mov    0x88(%rsp),%esi
mov    (%rsp),%rdi
jmp    12ac <mrqmin+0x12c>
lea    0x1(%rdi),%ecx
cmp    %ecx,%eax
jne    184a <mrqmin+0x6ca>
mov    0xb0(%rsp),%r11
movl   $0x3a83126f,(%r11)
mov    %rdi,%r9
mov    0x28(%rsp),%rdi
mov    0x30(%rsp),%rsi
mov    0x38(%rsp),%rdx
mov    0xc(%rsp),%ecx
mov    %r13,%r8
xor    %eax,%eax
push   0xa8(%rsp)
mov    0xa8(%rsp),%r14
push   %r14
push   %r10
mov    0xb0(%rsp),%r12
push   %r12
mov    0xa8(%rsp),%ebp
push   %rbp
mov    %r11,%rbp
push   %rbx
call   10a0 <mrqcof@plt>
mov    0xb8(%rsp),%esi
add    $0x30,%rsp
movss  (%r14),%xmm0
movss  %xmm0,0x2c51(%rip)
mov    0x90(%rsp),%rdi
test   %esi,%esi
jle    1789 <mrqmin+0x609>
mov    %r13,0x40(%rsp)
mov    0x2c2d(%rip),%r9
mov    0x2c1e(%rip),%rdx
mov    %esi,%r14d
lea    0x1(%r14),%r15
lea    -0x8(%r14),%rax
mov    %rax,0x20(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %r14d,%r11d
and    $0xfffffff8,%r11d
lea    0x1(%r11),%rcx
mov    %rcx,0x18(%rsp)
mov    %eax,%r10d
and    $0x3,%r10d
and    $0xfffffffffffffffc,%rax
mov    %rax,0x10(%rsp)
mov    $0x1,%ecx
movsd  0xb61(%rip),%xmm0
jmp    14fc <mrqmin+0x37c>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x0(%r13,%rcx,4),%xmm1
cvtss2sd %xmm1,%xmm1
movss  0x0(%rbp),%xmm2
cvtss2sd %xmm2,%xmm2
addsd  %xmm0,%xmm2
mulsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsd2ss %xmm2,%xmm1
movss  %xmm1,(%rdi,%rcx,4)
movd   (%r9,%rcx,4),%xmm1
mov    (%rdx,%rcx,8),%rax
movd   %xmm1,0x4(%rax)
add    $0x1,%rcx
cmp    %r15,%rcx
mov    0x90(%rsp),%rdi
je     16b5 <mrqmin+0x535>
mov    (%r12,%rcx,8),%r13
mov    (%rdi,%rcx,8),%rdi
mov    $0x1,%r8d
cmp    $0x8,%r14d
jb     1620 <mrqmin+0x4a0>
lea    0x4(%rdi),%rax
lea    0x0(,%r15,4),%rsi
add    %r13,%rsi
cmp    %rsi,%rax
jae    153f <mrqmin+0x3bf>
lea    (%rdi,%r15,4),%rax
lea    0x4(%r13),%rsi
mov    $0x1,%r8d
cmp    %rax,%rsi
jb     1620 <mrqmin+0x4a0>
cmpq   $0x18,0x20(%rsp)
jae    154b <mrqmin+0x3cb>
xor    %esi,%esi
jmp    15c6 <mrqmin+0x446>
mov    0x10(%rsp),%rax
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movups 0x4(%r13,%rsi,4),%xmm1
movups 0x14(%r13,%rsi,4),%xmm2
movups %xmm1,0x4(%rdi,%rsi,4)
movups %xmm2,0x14(%rdi,%rsi,4)
movups 0x24(%r13,%rsi,4),%xmm1
movups 0x34(%r13,%rsi,4),%xmm2
movups %xmm1,0x24(%rdi,%rsi,4)
movups %xmm2,0x34(%rdi,%rsi,4)
movups 0x44(%r13,%rsi,4),%xmm1
movups 0x54(%r13,%rsi,4),%xmm2
movups %xmm1,0x44(%rdi,%rsi,4)
movups %xmm2,0x54(%rdi,%rsi,4)
movdqu 0x64(%r13,%rsi,4),%xmm1
movdqu 0x74(%r13,%rsi,4),%xmm2
movdqu %xmm1,0x64(%rdi,%rsi,4)
movdqu %xmm2,0x74(%rdi,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rax
jne    1560 <mrqmin+0x3e0>
test   %r10,%r10
je     15ff <mrqmin+0x47f>
mov    %r10,%rax
xchg   %ax,%ax
lea    0x0(,%rsi,4),%rbp
or     $0x4,%rbp
movdqu 0x0(%r13,%rbp,1),%xmm1
movdqu 0x10(%r13,%rbp,1),%xmm2
movdqu %xmm1,(%rdi,%rbp,1)
movdqu %xmm2,0x10(%rdi,%rbp,1)
add    $0x8,%rsi
add    $0xffffffffffffffff,%rax
jne    15d0 <mrqmin+0x450>
mov    0x18(%rsp),%r8
cmp    %r11,%r14
mov    0x98(%rsp),%r12
mov    0xb0(%rsp),%rbp
je     14b0 <mrqmin+0x330>
nopl   (%rax)
mov    %r15d,%esi
sub    %r8d,%esi
mov    %r8,%rax
not    %rax
add    %r15,%rax
and    $0x3,%rsi
je     1657 <mrqmin+0x4d7>
cs nopw 0x0(%rax,%rax,1)
nop
movd   0x0(%r13,%r8,4),%xmm1
movd   %xmm1,(%rdi,%r8,4)
add    $0x1,%r8
add    $0xffffffffffffffff,%rsi
jne    1640 <mrqmin+0x4c0>
cmp    $0x3,%rax
jb     14b0 <mrqmin+0x330>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movss  0x0(%r13,%r8,4),%xmm1
movss  %xmm1,(%rdi,%r8,4)
movss  0x4(%r13,%r8,4),%xmm1
movss  %xmm1,0x4(%rdi,%r8,4)
movss  0x8(%r13,%r8,4),%xmm1
movss  %xmm1,0x8(%rdi,%r8,4)
movd   0xc(%r13,%r8,4),%xmm1
movd   %xmm1,0xc(%rdi,%r8,4)
add    $0x4,%r8
cmp    %r8,%r15
jne    1670 <mrqmin+0x4f0>
jmp    14b0 <mrqmin+0x330>
xor    %r12d,%r12d
mov    0x88(%rsp),%esi
mov    $0x1,%ecx
xor    %eax,%eax
call   1060 <gaussj@plt>
test   %eax,%eax
mov    0x40(%rsp),%r13
je     1d8b <mrqmin+0xc0b>
mov    0x88(%rsp),%eax
test   %eax,%eax
jle    17a7 <mrqmin+0x627>
mov    0x298a(%rip),%rcx
mov    0x2973(%rip),%rdx
add    $0xfffffffffffffffe,%r15
mov    %r14d,%eax
and    $0x3,%eax
mov    $0x1,%esi
cmp    $0x3,%r15
jb     175d <mrqmin+0x5dd>
and    $0xfffffffc,%r14d
xor    %esi,%esi
mov    0x8(%rcx,%rsi,8),%rdi
movss  0x4(%rdi),%xmm0
movss  %xmm0,0x4(%rdx,%rsi,4)
mov    0x10(%rcx,%rsi,8),%rdi
movss  0x4(%rdi),%xmm0
movss  %xmm0,0x8(%rdx,%rsi,4)
mov    0x18(%rcx,%rsi,8),%rdi
movss  0x4(%rdi),%xmm0
movss  %xmm0,0xc(%rdx,%rsi,4)
mov    0x20(%rcx,%rsi,8),%rdi
movss  0x4(%rdi),%xmm0
movss  %xmm0,0x10(%rdx,%rsi,4)
add    $0x4,%rsi
cmp    %rsi,%r14
jne    1710 <mrqmin+0x590>
add    $0x1,%rsi
test   %rax,%rax
je     17a7 <mrqmin+0x627>
lea    (%rdx,%rsi,4),%rdx
lea    (%rcx,%rsi,8),%rcx
xor    %esi,%esi
nopl   0x0(%rax)
mov    (%rcx,%rsi,8),%rdi
movss  0x4(%rdi),%xmm0
movss  %xmm0,(%rdx,%rsi,4)
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1770 <mrqmin+0x5f0>
jmp    17a7 <mrqmin+0x627>
mov    0x28e8(%rip),%rdx
xor    %r12d,%r12d
mov    $0x1,%ecx
xor    %eax,%eax
call   1060 <gaussj@plt>
test   %eax,%eax
je     1d8b <mrqmin+0xc0b>
movss  0x0(%rbp),%xmm0
pxor   %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jne    1856 <mrqmin+0x6d6>
jp     1856 <mrqmin+0x6d6>
mov    0x90(%rsp),%rdi
mov    (%rsp),%rbp
mov    %ebp,%esi
mov    %rbx,%rdx
mov    0x88(%rsp),%ebx
mov    %ebx,%ecx
xor    %eax,%eax
call   1070 <covsrt@plt>
mov    0x2899(%rip),%rdi
mov    $0x1,%r12d
mov    $0x1,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   1050 <free_vector@plt>
mov    0x2866(%rip),%rdi
mov    $0x1,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   1050 <free_vector@plt>
mov    0x2859(%rip),%rdi
mov    $0x1,%esi
mov    %ebp,%edx
xor    %eax,%eax
call   1050 <free_vector@plt>
mov    0x284c(%rip),%rdi
mov    $0x1,%esi
mov    %ebx,%edx
mov    $0x1,%ecx
mov    $0x1,%r8d
xor    %eax,%eax
call   1030 <free_matrix@plt>
jmp    1d8b <mrqmin+0xc0b>
lea    0x7e5(%rip),%rdi
jmp    18d9 <mrqmin+0x759>
mov    (%rsp),%rsi
test   %esi,%esi
mov    0xa0(%rsp),%r14
jle    1a0c <mrqmin+0x88c>
mov    0x27ff(%rip),%rax
mov    %esi,%r8d
lea    0x1(%r8),%rcx
mov    $0x1,%edx
cmp    $0x8,%esi
jb     1994 <mrqmin+0x814>
lea    0x4(%rax),%rsi
lea    0x0(,%rcx,4),%rdi
add    %r13,%rdi
cmp    %rdi,%rsi
jae    18ab <mrqmin+0x72b>
lea    (%rax,%rcx,4),%rsi
lea    0x4(%r13),%rdi
cmp    %rsi,%rdi
jb     1994 <mrqmin+0x814>
mov    %r8d,%edx
and    $0xfffffff8,%edx
lea    -0x8(%rdx),%rbp
mov    %rbp,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%esi
and    $0x3,%esi
cmp    $0x18,%rbp
jae    18e8 <mrqmin+0x768>
xor    %ebp,%ebp
jmp    1952 <mrqmin+0x7d2>
lea    0x73b(%rip),%rdi
xor    %r12d,%r12d
xor    %eax,%eax
call   1040 <nrerror@plt>
jmp    1d8b <mrqmin+0xc0b>
and    $0xfffffffffffffffc,%rdi
xor    %ebp,%ebp
xchg   %ax,%ax
movups 0x4(%r13,%rbp,4),%xmm0
movups 0x14(%r13,%rbp,4),%xmm1
movups %xmm0,0x4(%rax,%rbp,4)
movups %xmm1,0x14(%rax,%rbp,4)
movups 0x24(%r13,%rbp,4),%xmm0
movups 0x34(%r13,%rbp,4),%xmm1
movups %xmm0,0x24(%rax,%rbp,4)
movups %xmm1,0x34(%rax,%rbp,4)
movups 0x44(%r13,%rbp,4),%xmm0
movups 0x54(%r13,%rbp,4),%xmm1
movups %xmm0,0x44(%rax,%rbp,4)
movups %xmm1,0x54(%rax,%rbp,4)
movups 0x64(%r13,%rbp,4),%xmm0
movups 0x74(%r13,%rbp,4),%xmm1
movups %xmm0,0x64(%rax,%rbp,4)
movups %xmm1,0x74(%rax,%rbp,4)
add    $0x20,%rbp
add    $0xfffffffffffffffc,%rdi
jne    18f0 <mrqmin+0x770>
test   %rsi,%rsi
je     198b <mrqmin+0x80b>
nopw   0x0(%rax,%rax,1)
lea    0x0(,%rbp,4),%rdi
or     $0x4,%rdi
movups 0x0(%r13,%rdi,1),%xmm0
movups 0x10(%r13,%rdi,1),%xmm1
movups %xmm0,(%rax,%rdi,1)
movups %xmm1,0x10(%rax,%rdi,1)
add    $0x8,%rbp
add    $0xffffffffffffffff,%rsi
jne    1960 <mrqmin+0x7e0>
cmp    %rdx,%r8
je     1a0c <mrqmin+0x88c>
or     $0x1,%rdx
mov    %ecx,%edi
sub    %edx,%edi
mov    %rdx,%rsi
not    %rsi
add    %rcx,%rsi
and    $0x3,%rdi
je     19c6 <mrqmin+0x846>
nopw   0x0(%rax,%rax,1)
movss  0x0(%r13,%rdx,4),%xmm0
movss  %xmm0,(%rax,%rdx,4)
add    $0x1,%rdx
add    $0xffffffffffffffff,%rdi
jne    19b0 <mrqmin+0x830>
cmp    $0x3,%rsi
jb     1a0c <mrqmin+0x88c>
nopl   0x0(%rax)
movss  0x0(%r13,%rdx,4),%xmm0
movss  %xmm0,(%rax,%rdx,4)
movss  0x4(%r13,%rdx,4),%xmm0
movss  %xmm0,0x4(%rax,%rdx,4)
movss  0x8(%r13,%rdx,4),%xmm0
movss  %xmm0,0x8(%rax,%rdx,4)
movss  0xc(%r13,%rdx,4),%xmm0
movss  %xmm0,0xc(%rax,%rdx,4)
add    $0x4,%rdx
cmp    %rdx,%rcx
jne    19d0 <mrqmin+0x850>
mov    0x88(%rsp),%edx
test   %edx,%edx
jle    1aae <mrqmin+0x92e>
mov    0x2646(%rip),%rbp
mov    0x2647(%rip),%r8
mov    %edx,%eax
mov    $0x1,%ecx
cmp    $0x1,%edx
je     1a91 <mrqmin+0x911>
mov    %eax,%edx
and    $0xfffffffe,%edx
neg    %rdx
mov    $0x1,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movslq (%rbx,%rcx,4),%rsi
movss  0x0(%r13,%rsi,4),%xmm0
addss  0x0(%rbp,%rcx,4),%xmm0
movss  %xmm0,(%r8,%rsi,4)
movslq 0x4(%rbx,%rcx,4),%rsi
movss  0x0(%r13,%rsi,4),%xmm0
addss  0x4(%rbp,%rcx,4),%xmm0
movss  %xmm0,(%r8,%rsi,4)
lea    (%rdx,%rcx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rcx
cmp    $0x1,%rsi
jne    1a50 <mrqmin+0x8d0>
test   $0x1,%al
je     1abc <mrqmin+0x93c>
movslq (%rbx,%rcx,4),%rax
movss  0x0(%r13,%rax,4),%xmm0
addss  0x0(%rbp,%rcx,4),%xmm0
movss  %xmm0,(%r8,%rax,4)
jmp    1abc <mrqmin+0x93c>
mov    0x25bb(%rip),%r8
mov    0x25ac(%rip),%rbp
mov    0x28(%rsp),%rdi
mov    0x30(%rsp),%rsi
mov    0x38(%rsp),%rdx
mov    0xc(%rsp),%ecx
mov    (%rsp),%r9
xor    %eax,%eax
push   0xa8(%rsp)
push   %r14
push   %rbp
push   0xa8(%rsp)
mov    0xa8(%rsp),%ebp
push   %rbp
push   %rbx
call   10a0 <mrqcof@plt>
add    $0x30,%rsp
movss  0x2588(%rip),%xmm0
ucomiss (%r14),%xmm0
mov    0xb0(%rsp),%rax
movss  (%rax),%xmm1
jbe    1d74 <mrqmin+0xbf4>
xorps  %xmm0,%xmm0
cvtss2sd %xmm1,%xmm0
mulsd  0x4e3(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,(%rax)
movss  (%r14),%xmm0
movss  %xmm0,0x254e(%rip)
mov    $0x1,%r12d
test   %ebp,%ebp
jle    1d8b <mrqmin+0xc0b>
mov    0x2519(%rip),%r12
mov    0x252a(%rip),%r8
mov    0x2513(%rip),%r14
mov    %ebp,%r11d
lea    0x1(%r11),%rdi
lea    -0x8(%r11),%rax
mov    %rax,(%rsp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %r11d,%ecx
and    $0xfffffff8,%ecx
mov    %rcx,0x20(%rsp)
add    $0x1,%rcx
mov    %rcx,0x18(%rsp)
mov    %eax,%r15d
and    $0x3,%r15d
and    $0xfffffffffffffffc,%rax
mov    %rax,0x10(%rsp)
mov    $0x1,%r9d
mov    0x98(%rsp),%rbp
jmp    1bda <mrqmin+0xa5a>
nopl   0x0(%rax,%rax,1)
movss  (%r12,%r9,4),%xmm0
movss  %xmm0,(%r8,%r9,4)
movslq (%rbx,%r9,4),%rax
movss  (%r14,%rax,4),%xmm0
movss  %xmm0,0x0(%r13,%rax,4)
add    $0x1,%r9
cmp    %rdi,%r9
je     1d85 <mrqmin+0xc05>
mov    0x90(%rsp),%rax
mov    (%rax,%r9,8),%rax
mov    0x0(%rbp,%r9,8),%rcx
mov    $0x1,%r10d
cmp    $0x8,%r11d
jb     1cf0 <mrqmin+0xb70>
lea    0x4(%rcx),%rdx
lea    (%rax,%rdi,4),%rsi
cmp    %rsi,%rdx
jae    1c1f <mrqmin+0xa9f>
lea    (%rcx,%rdi,4),%rdx
lea    0x4(%rax),%rsi
mov    $0x1,%r10d
cmp    %rdx,%rsi
jb     1cf0 <mrqmin+0xb70>
cmpq   $0x18,(%rsp)
jae    1c2a <mrqmin+0xaaa>
xor    %edx,%edx
jmp    1c9a <mrqmin+0xb1a>
mov    0x10(%rsp),%rsi
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movups 0x4(%rax,%rdx,4),%xmm0
movups 0x14(%rax,%rdx,4),%xmm1
movups %xmm0,0x4(%rcx,%rdx,4)
movups %xmm1,0x14(%rcx,%rdx,4)
movups 0x24(%rax,%rdx,4),%xmm0
movups 0x34(%rax,%rdx,4),%xmm1
movups %xmm0,0x24(%rcx,%rdx,4)
movups %xmm1,0x34(%rcx,%rdx,4)
movups 0x44(%rax,%rdx,4),%xmm0
movups 0x54(%rax,%rdx,4),%xmm1
movups %xmm0,0x44(%rcx,%rdx,4)
movups %xmm1,0x54(%rcx,%rdx,4)
movups 0x64(%rax,%rdx,4),%xmm0
movups 0x74(%rax,%rdx,4),%xmm1
movups %xmm0,0x64(%rcx,%rdx,4)
movups %xmm1,0x74(%rcx,%rdx,4)
add    $0x20,%rdx
add    $0xfffffffffffffffc,%rsi
jne    1c40 <mrqmin+0xac0>
test   %r15,%r15
je     1cd8 <mrqmin+0xb58>
mov    %r15,%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
lea    0x0(,%rdx,4),%rbp
or     $0x4,%rbp
movups (%rax,%rbp,1),%xmm0
movups 0x10(%rax,%rbp,1),%xmm1
movups %xmm0,(%rcx,%rbp,1)
movups %xmm1,0x10(%rcx,%rbp,1)
add    $0x8,%rdx
add    $0xffffffffffffffff,%rsi
jne    1cb0 <mrqmin+0xb30>
mov    0x18(%rsp),%r10
cmp    0x20(%rsp),%r11
mov    0x98(%rsp),%rbp
je     1bb0 <mrqmin+0xa30>
mov    %edi,%esi
sub    %r10d,%esi
mov    %r10,%rdx
not    %rdx
add    %rdi,%rdx
and    $0x3,%rsi
je     1d26 <mrqmin+0xba6>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movss  (%rax,%r10,4),%xmm0
movss  %xmm0,(%rcx,%r10,4)
add    $0x1,%r10
add    $0xffffffffffffffff,%rsi
jne    1d10 <mrqmin+0xb90>
cmp    $0x3,%rdx
jb     1bb0 <mrqmin+0xa30>
movss  (%rax,%r10,4),%xmm0
movss  %xmm0,(%rcx,%r10,4)
movss  0x4(%rax,%r10,4),%xmm0
movss  %xmm0,0x4(%rcx,%r10,4)
movss  0x8(%rax,%r10,4),%xmm0
movss  %xmm0,0x8(%rcx,%r10,4)
movss  0xc(%rax,%r10,4),%xmm0
movss  %xmm0,0xc(%rcx,%r10,4)
add    $0x4,%r10
cmp    %r10,%rdi
jne    1d30 <mrqmin+0xbb0>
jmp    1bb0 <mrqmin+0xa30>
mulss  0x294(%rip),%xmm1
movss  %xmm1,(%rax)
movss  %xmm0,(%r14)
mov    $0x1,%r12d
mov    %r12d,%eax
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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