#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_fvector(float *, int, int);
float *fvector(int, int);
void stub1(float *, float *, float *, float *, int);
void mrqcofx(float x[], int xdim, 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 i, i2, j, k, l, m, mfit = 0;
  float ymod, wt, sig2i, dy, *dyda;
  dyda = fvector(1, ma);
  for (j = 1; j <= ma; j++)
    if (ia[j])
      mfit++;
  for (j = 1; j <= mfit; j++) {
    for (k = 1; k <= j; k++)
      alpha[j][k] = 0.0;
    beta[j] = 0.0;
  }
  *chisq = 0.0;
  for (i = 1, i2 = 1; i <= ndata; i++, i2 += xdim) {
    (*funcs)(&x[i2], a, &ymod, dyda, ma);
    sig2i = 1.0 / (sig[i] * sig[i]);
    dy = y[i] - ymod;
    for (j = 0, l = 1; l <= ma; l++) {
      if (ia[l]) {
        wt = dyda[l] * sig2i;
        for (j++, k = 0, m = 1; m <= l; m++)
          if (ia[m])
            alpha[j][++k] += wt * dyda[m];
        beta[j] += dy * wt;
      }
    }
    *chisq += dy * dy * sig2i;
  }
  for (j = 2; j <= mfit; j++)
    for (k = 1; k < j; k++)
      alpha[k][j] = alpha[j][k];
  free_fvector(dyda, 1, ma);
}


x86 assembly (clang, -O0):
<mrqcofx>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
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,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    0x18(%rbp),%esi
mov    $0x1,%edi
call   1040 <fvector@plt>
mov    %rax,-0x68(%rbp)
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     11af <mrqcofx+0x8f>
mov    0x10(%rbp),%rax
movslq -0x3c(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     119c <mrqcofx+0x7c>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    11a1 <mrqcofx+0x81>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    1175 <mrqcofx+0x55>
movl   $0x1,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     1219 <mrqcofx+0xf9>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jg     11fb <mrqcofx+0xdb>
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11c9 <mrqcofx+0xa9>
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax,%rcx,4)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11b6 <mrqcofx+0x96>
mov    0x30(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
movl   $0x1,-0x34(%rbp)
movl   $0x1,-0x38(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     13e5 <mrqcofx+0x2c5>
mov    0x38(%rbp),%rax
mov    -0x8(%rbp),%rdi
movslq -0x38(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rdi
mov    -0x30(%rbp),%rsi
mov    -0x68(%rbp),%rcx
mov    0x18(%rbp),%r8d
lea    -0x50(%rbp),%rdx
call   *%rax
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xd77(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x58(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x5c(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x1,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    0x18(%rbp),%eax
jg     13ab <mrqcofx+0x28b>
mov    0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1398 <mrqcofx+0x278>
mov    -0x68(%rbp),%rax
movslq -0x44(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mulss  -0x58(%rbp),%xmm0
movss  %xmm0,-0x54(%rbp)
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
movl   $0x0,-0x40(%rbp)
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jg     1374 <mrqcofx+0x254>
mov    0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     1361 <mrqcofx+0x241>
movss  -0x54(%rbp),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x48(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
add    $0x1,%ecx
mov    %ecx,-0x40(%rbp)
movslq %ecx,%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    1366 <mrqcofx+0x246>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1307 <mrqcofx+0x1e7>
movss  -0x5c(%rbp),%xmm0
movss  -0x54(%rbp),%xmm2
mov    0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax,%rcx,4)
jmp    139d <mrqcofx+0x27d>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    12bb <mrqcofx+0x19b>
movss  -0x5c(%rbp),%xmm0
mulss  -0x5c(%rbp),%xmm0
movss  -0x58(%rbp),%xmm2
mov    0x30(%rbp),%rax
movss  (%rax),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
mov    -0xc(%rbp),%eax
add    -0x38(%rbp),%eax
mov    %eax,-0x38(%rbp)
jmp    1232 <mrqcofx+0x112>
movl   $0x2,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
cmp    -0x4c(%rbp),%eax
jg     1456 <mrqcofx+0x336>
movl   $0x1,-0x40(%rbp)
mov    -0x40(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    1443 <mrqcofx+0x323>
mov    0x20(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x40(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
mov    0x20(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x3c(%rbp),%rcx
movss  %xmm0,(%rax,%rcx,4)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    13ff <mrqcofx+0x2df>
jmp    1448 <mrqcofx+0x328>
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    13ec <mrqcofx+0x2cc>
mov    -0x68(%rbp),%rdi
mov    0x18(%rbp),%edx
mov    $0x1,%esi
call   1030 <free_fvector@plt>
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mrqcofx>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x48,%rsp
mov    %r9,0x40(%rsp)
mov    %r8,(%rsp)
mov    %rcx,0x38(%rsp)
mov    %rdx,0x30(%rsp)
mov    %esi,%ebp
mov    %rdi,0x28(%rsp)
mov    0x90(%rsp),%r13
mov    0x88(%rsp),%ebx
mov    0x80(%rsp),%r12
mov    $0x1,%edi
mov    %ebx,%esi
call   1050 <fvector@plt>
mov    %rbx,%r8
mov    %rax,%rbx
test   %r8d,%r8d
jle    12d0 <mrqcofx+0x1a0>
mov    %r8d,%eax
cmp    $0x8,%r8d
jae    119f <mrqcofx+0x6f>
xor    %edx,%edx
mov    $0x1,%ecx
jmp    128a <mrqcofx+0x15a>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
test   %rsi,%rsi
je     15fd <mrqcofx+0x4cd>
mov    %rdx,%rdi
and    $0xfffffffffffffffe,%rdi
pxor   %xmm2,%xmm2
mov    $0x1,%esi
movdqa 0xe2c(%rip),%xmm3
pxor   %xmm5,%xmm5
pxor   %xmm4,%xmm4
nopl   0x0(%rax)
movdqu (%r12,%rsi,4),%xmm6
movdqu 0x10(%r12,%rsi,4),%xmm7
movdqu 0x20(%r12,%rsi,4),%xmm0
movdqu 0x30(%r12,%rsi,4),%xmm1
pcmpeqd %xmm2,%xmm6
paddd  %xmm5,%xmm6
pcmpeqd %xmm2,%xmm7
paddd  %xmm4,%xmm7
pcmpeqd %xmm2,%xmm0
pcmpeqd %xmm2,%xmm1
paddd  %xmm3,%xmm0
paddd  %xmm6,%xmm0
paddd  %xmm3,%xmm1
paddd  %xmm7,%xmm1
add    $0x10,%rsi
movdqa %xmm0,%xmm5
movdqa %xmm1,%xmm4
add    $0xfffffffffffffffe,%rdi
jne    11e0 <mrqcofx+0xb0>
test   $0x1,%dl
je     1267 <mrqcofx+0x137>
movdqu (%r12,%rsi,4),%xmm2
movdqu 0x10(%r12,%rsi,4),%xmm3
pxor   %xmm4,%xmm4
pcmpeqd %xmm4,%xmm2
paddd  %xmm2,%xmm0
pcmpeqd %xmm4,%xmm3
paddd  %xmm3,%xmm1
pcmpeqd %xmm2,%xmm2
psubd  %xmm2,%xmm0
psubd  %xmm2,%xmm1
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edx
cmp    %rcx,%rax
je     12a1 <mrqcofx+0x171>
or     $0x1,%rcx
add    $0x1,%rax
xchg   %ax,%ax
cmpl   $0x1,(%r12,%rcx,4)
sbb    $0xffffffff,%edx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1290 <mrqcofx+0x160>
test   %edx,%edx
je     12d0 <mrqcofx+0x1a0>
mov    %ebp,0x8(%rsp)
mov    %edx,%r14d
cmp    $0x1,%edx
mov    %rdx,0x10(%rsp)
jne    12dc <mrqcofx+0x1ac>
mov    $0x4,%r15d
mov    $0x1,%ebp
test   $0x1,%r14b
jne    1373 <mrqcofx+0x243>
jmp    139b <mrqcofx+0x26b>
xor    %eax,%eax
mov    %rax,0x10(%rsp)
jmp    139f <mrqcofx+0x26f>
mov    %r14,0x18(%rsp)
and    $0xfffffffe,%r14d
neg    %r14
mov    $0x1,%ebp
mov    $0x8,%r15d
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    -0x4(%r15),%rdx
mov    0x0(%r13,%rbp,8),%rdi
add    $0x4,%rdi
xor    %esi,%esi
call   1040 <memset@plt>
mov    0x98(%rsp),%rax
movl   $0x0,(%rax,%rbp,4)
mov    0x8(%r13,%rbp,8),%rdi
add    $0x4,%rdi
xor    %esi,%esi
mov    %r15,%rdx
call   1040 <memset@plt>
mov    0x98(%rsp),%rax
movl   $0x0,0x4(%rax,%rbp,4)
add    $0x8,%r15
lea    (%r14,%rbp,1),%rax
add    $0x2,%rax
add    $0x2,%rbp
cmp    $0x1,%rax
jne    1300 <mrqcofx+0x1d0>
add    $0xfffffffffffffffc,%r15
mov    0x88(%rsp),%r8d
mov    0x18(%rsp),%r14
test   $0x1,%r14b
je     139b <mrqcofx+0x26b>
mov    0x0(%r13,%rbp,8),%rdi
add    $0x4,%rdi
xor    %esi,%esi
mov    %r15,%rdx
mov    %r8,%r14
call   1040 <memset@plt>
mov    %r14,%r8
mov    0x98(%rsp),%rax
movl   $0x0,(%rax,%rbp,4)
mov    0x8(%rsp),%ebp
mov    0xa0(%rsp),%rax
movl   $0x0,(%rax)
cmpl   $0x0,(%rsp)
jle    14f4 <mrqcofx+0x3c4>
lea    0x1(%r8),%r15d
movslq %ebp,%rax
mov    %rax,0x18(%rsp)
mov    (%rsp),%rax
add    $0x1,%eax
mov    %rax,(%rsp)
mov    $0x1,%ecx
mov    $0x1,%r14d
jmp    1410 <mrqcofx+0x2e0>
nopl   0x0(%rax,%rax,1)
mulss  %xmm0,%xmm0
mulss  %xmm1,%xmm0
mov    0xa0(%rsp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
add    $0x1,%r14
mov    0x8(%rsp),%rcx
add    0x18(%rsp),%rcx
cmp    (%rsp),%r14
je     14f4 <mrqcofx+0x3c4>
mov    0x28(%rsp),%rax
mov    %rcx,0x8(%rsp)
lea    (%rax,%rcx,4),%rdi
mov    0x40(%rsp),%rsi
lea    0x24(%rsp),%rdx
mov    %rbx,%rcx
mov    %r8,%rbp
call   *0xa8(%rsp)
mov    0x98(%rsp),%r10
mov    %rbp,%r8
mov    0x38(%rsp),%rax
movss  (%rax,%r14,4),%xmm0
mulss  %xmm0,%xmm0
movss  0xbb9(%rip),%xmm1
divss  %xmm0,%xmm1
mov    0x30(%rsp),%rax
movss  (%rax,%r14,4),%xmm0
subss  0x24(%rsp),%xmm0
test   %r8d,%r8d
jle    13e0 <mrqcofx+0x2b0>
xor    %r9d,%r9d
mov    $0x1,%ecx
jmp    149d <mrqcofx+0x36d>
nop
mulss  %xmm0,%xmm2
addss  (%r10,%rdx,4),%xmm2
movss  %xmm2,(%r10,%rdx,4)
add    $0x1,%rcx
cmp    %r15,%rcx
je     13e0 <mrqcofx+0x2b0>
cmpl   $0x0,(%r12,%rcx,4)
je     1490 <mrqcofx+0x360>
movss  (%rbx,%rcx,4),%xmm2
mulss  %xmm1,%xmm2
add    $0x1,%r9d
movslq %r9d,%rdx
xor    %esi,%esi
xor    %edi,%edi
jmp    14c9 <mrqcofx+0x399>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rsi
cmp    %rsi,%rcx
je     1480 <mrqcofx+0x350>
cmpl   $0x0,0x4(%r12,%rsi,4)
je     14c0 <mrqcofx+0x390>
mov    0x0(%r13,%rdx,8),%rbp
movslq %edi,%rax
add    $0x1,%edi
movss  0x4(%rbx,%rsi,4),%xmm3
mulss  %xmm2,%xmm3
addss  0x4(%rbp,%rax,4),%xmm3
movss  %xmm3,0x4(%rbp,%rax,4)
jmp    14c0 <mrqcofx+0x390>
mov    0x10(%rsp),%r11
cmp    $0x2,%r11d
jae    151e <mrqcofx+0x3ee>
mov    %rbx,%rdi
mov    $0x1,%esi
mov    %r8d,%edx
call   1030 <free_fvector@plt>
add    $0x48,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
add    $0x1,%r11d
mov    $0x2,%eax
mov    $0x1,%r9d
xor    %r10d,%r10d
jmp    154d <mrqcofx+0x41d>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rax
add    $0x1,%r9
cmp    %r11,%rax
je     14ff <mrqcofx+0x3cf>
mov    %r10,%rcx
add    $0x1,%r10
mov    0x0(%r13,%rax,8),%rsi
mov    $0x1,%edi
cmp    $0x3,%rcx
jb     15bd <mrqcofx+0x48d>
mov    %r9,%rcx
and    $0xfffffffffffffffc,%rcx
xor    %edi,%edi
nopl   (%rax)
movss  0x4(%rsi,%rdi,4),%xmm0
mov    0x8(%r13,%rdi,8),%rdx
movss  %xmm0,(%rdx,%rax,4)
movss  0x8(%rsi,%rdi,4),%xmm0
mov    0x10(%r13,%rdi,8),%rdx
movss  %xmm0,(%rdx,%rax,4)
movss  0xc(%rsi,%rdi,4),%xmm0
mov    0x18(%r13,%rdi,8),%rdx
movss  %xmm0,(%rdx,%rax,4)
movd   0x10(%rsi,%rdi,4),%xmm0
mov    0x20(%r13,%rdi,8),%rdx
movd   %xmm0,(%rdx,%rax,4)
add    $0x4,%rdi
cmp    %rdi,%rcx
jne    1570 <mrqcofx+0x440>
add    $0x1,%rdi
test   $0x3,%r10b
je     1540 <mrqcofx+0x410>
mov    %r9d,%ecx
and    $0x3,%ecx
lea    0x0(,%rdi,8),%rdx
add    %r13,%rdx
lea    (%rsi,%rdi,4),%rsi
xor    %edi,%edi
xchg   %ax,%ax
movd   (%rsi,%rdi,4),%xmm0
mov    (%rdx,%rdi,8),%rbp
movd   %xmm0,0x0(%rbp,%rax,4)
add    $0x1,%rdi
cmp    %rdi,%rcx
jne    15e0 <mrqcofx+0x4b0>
jmp    1540 <mrqcofx+0x410>
pxor   %xmm0,%xmm0
mov    $0x1,%esi
pxor   %xmm1,%xmm1
test   $0x1,%dl
jne    123a <mrqcofx+0x10a>
jmp    1267 <mrqcofx+0x137>

LLVM IR (-O0):
define void @mrqcofx(float* %0, i32 %1, float* %2, float* %3, i32 %4, float* %5, i32* %6, i32 %7, float** %8, float* %9, float* %10, void (float*, float*, float*, float*, i32)* %11) {
%13 = alloca float*
%14 = alloca i32
%15 = alloca float*
%16 = alloca float*
%17 = alloca i32
%18 = alloca float*
%19 = alloca i32*
%20 = alloca i32
%21 = alloca float**
%22 = alloca float*
%23 = alloca float*
%24 = alloca void (float*, float*, float*, float*, i32)*
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
%28 = alloca i32
%29 = alloca i32
%30 = alloca i32
%31 = alloca i32
%32 = alloca float
%33 = alloca float
%34 = alloca float
%35 = alloca float
%36 = alloca float*
store float* %0, float** %13
store i32 %1, i32* %14
store float* %2, float** %15
store float* %3, float** %16
store i32 %4, i32* %17
store float* %5, float** %18
store i32* %6, i32** %19
store i32 %7, i32* %20
store float** %8, float*** %21
store float* %9, float** %22
store float* %10, float** %23
store void (float*, float*, float*, float*, i32)* %11, void (float*, float*, float*, float*, i32)** %24
store i32 0, i32* %31
%37 = load i32, i32* %20
%38 = call float* @fvector(i32 1, i32 %37)
store float* %38, float** %36
store i32 1, i32* %27
br label %39
39: ; preds = %54, %12
%40 = load i32, i32* %27
%41 = load i32, i32* %20
%42 = icmp sle i32 %40, %41
br i1 %42, label %43, label %57
43: ; preds = %39
%44 = load i32*, i32** %19
%45 = load i32, i32* %27
%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* %31
%52 = add nsw i32 %51, 1
store i32 %52, i32* %31
br label %53
53: ; preds = %50, %43
br label %54
54: ; preds = %53
%55 = load i32, i32* %27
%56 = add nsw i32 %55, 1
store i32 %56, i32* %27
br label %39
57: ; preds = %39
store i32 1, i32* %27
br label %58
58: ; preds = %84, %57
%59 = load i32, i32* %27
%60 = load i32, i32* %31
%61 = icmp sle i32 %59, %60
br i1 %61, label %62, label %87
62: ; preds = %58
store i32 1, i32* %28
br label %63
63: ; preds = %76, %62
%64 = load i32, i32* %28
%65 = load i32, i32* %27
%66 = icmp sle i32 %64, %65
br i1 %66, label %67, label %79
67: ; preds = %63
%68 = load float**, float*** %21
%69 = load i32, i32* %27
%70 = sext i32 %69 to i64
%71 = getelementptr inbounds float*, float** %68, i64 %70
%72 = load float*, float** %71
%73 = load i32, i32* %28
%74 = sext i32 %73 to i64
%75 = getelementptr inbounds float, float* %72, i64 %74
store float 0.000000e+00, float* %75
br label %76
76: ; preds = %67
%77 = load i32, i32* %28
%78 = add nsw i32 %77, 1
store i32 %78, i32* %28
br label %63
79: ; preds = %63
%80 = load float*, float** %22
%81 = load i32, i32* %27
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds float, float* %80, i64 %82
store float 0.000000e+00, float* %83
br label %84
84: ; preds = %79
%85 = load i32, i32* %27
%86 = add nsw i32 %85, 1
store i32 %86, i32* %27
br label %58
87: ; preds = %58
%88 = load float*, float** %23
store float 0.000000e+00, float* %88
store i32 1, i32* %25
store i32 1, i32* %26
br label %89
89: ; preds = %198, %87
%90 = load i32, i32* %25
%91 = load i32, i32* %17
%92 = icmp sle i32 %90, %91
br i1 %92, label %93, label %204
93: ; preds = %89
%94 = load void (float*, float*, float*, float*, i32)*, void (float*, float*, float*, float*, i32)** %24
%95 = load float*, float** %13
%96 = load i32, i32* %26
%97 = sext i32 %96 to i64
%98 = getelementptr inbounds float, float* %95, i64 %97
%99 = load float*, float** %18
%100 = load float*, float** %36
%101 = load i32, i32* %20
%102 = load float*, float** %16
%103 = load i32, i32* %25
%104 = sext i32 %103 to i64
%105 = getelementptr inbounds float, float* %102, i64 %104
%106 = load float, float* %105
%107 = load float*, float** %16
%108 = load i32, i32* %25
%109 = sext i32 %108 to i64
%110 = getelementptr inbounds float, float* %107, i64 %109
%111 = load float, float* %110
%112 = fmul float %106, %111
%113 = fpext float %112 to double
%114 = fdiv double 1.000000e+00, %113
%115 = fptrunc double %114 to float
store float %115, float* %34
%116 = load float*, float** %15
%117 = load i32, i32* %25
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds float, float* %116, i64 %118
%120 = load float, float* %119
%121 = load float, float* %32
%122 = fsub float %120, %121
store float %122, float* %35
store i32 0, i32* %27
store i32 1, i32* %29
br label %123
123: ; preds = %187, %93
%124 = load i32, i32* %29
%125 = load i32, i32* %20
%126 = icmp sle i32 %124, %125
br i1 %126, label %127, label %190
127: ; preds = %123
%128 = load i32*, i32** %19
%129 = load i32, i32* %29
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds i32, i32* %128, i64 %130
%132 = load i32, i32* %131
%133 = icmp ne i32 %132, 0
br i1 %133, label %134, label %186
134: ; preds = %127
%135 = load float*, float** %36
%136 = load i32, i32* %29
%137 = sext i32 %136 to i64
%138 = getelementptr inbounds float, float* %135, i64 %137
%139 = load float, float* %138
%140 = load float, float* %34
%141 = fmul float %139, %140
store float %141, float* %33
%142 = load i32, i32* %27
%143 = add nsw i32 %142, 1
store i32 %143, i32* %27
store i32 0, i32* %28
store i32 1, i32* %30
br label %144
144: ; preds = %174, %134
%145 = load i32, i32* %30
%146 = load i32, i32* %29
%147 = icmp sle i32 %145, %146
br i1 %147, label %148, label %177
148: ; preds = %144
%149 = load i32*, i32** %19
%150 = load i32, i32* %30
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds i32, i32* %149, i64 %151
%153 = load i32, i32* %152
%154 = icmp ne i32 %153, 0
br i1 %154, label %155, label %173
155: ; preds = %148
%156 = load float, float* %33
%157 = load float*, float** %36
%158 = load i32, i32* %30
%159 = sext i32 %158 to i64
%160 = getelementptr inbounds float, float* %157, i64 %159
%161 = load float, float* %160
%162 = load float**, float*** %21
%163 = load i32, i32* %27
%164 = sext i32 %163 to i64
%165 = getelementptr inbounds float*, float** %162, i64 %164
%166 = load float*, float** %165
%167 = load i32, i32* %28
%168 = add nsw i32 %167, 1
store i32 %168, i32* %28
%169 = sext i32 %168 to i64
%170 = getelementptr inbounds float, float* %166, i64 %169
%171 = load float, float* %170
%172 = call float @llvm.fmuladd.f32(float %156, float %161, float %171)
store float %172, float* %170
br label %173
173: ; preds = %155, %148
br label %174
174: ; preds = %173
%175 = load i32, i32* %30
%176 = add nsw i32 %175, 1
store i32 %176, i32* %30
br label %144
177: ; preds = %144
%178 = load float, float* %35
%179 = load float, float* %33
%180 = load float*, float** %22
%181 = load i32, i32* %27
%182 = sext i32 %181 to i64
%183 = getelementptr inbounds float, float* %180, i64 %182
%184 = load float, float* %183
%185 = call float @llvm.fmuladd.f32(float %178, float %179, float %184)
store float %185, float* %183
br label %186
186: ; preds = %177, %127
br label %187
187: ; preds = %186
%188 = load i32, i32* %29
%189 = add nsw i32 %188, 1
store i32 %189, i32* %29
br label %123
190: ; preds = %123
%191 = load float, float* %35
%192 = load float, float* %35
%193 = fmul float %191, %192
%194 = load float, float* %34
%195 = load float*, float** %23
%196 = load float, float* %195
%197 = call float @llvm.fmuladd.f32(float %193, float %194, float %196)
store float %197, float* %195
br label %198
198: ; preds = %190
%199 = load i32, i32* %25
%200 = add nsw i32 %199, 1
store i32 %200, i32* %25
%201 = load i32, i32* %14
%202 = load i32, i32* %26
%203 = add nsw i32 %202, %201
store i32 %203, i32* %26
br label %89
204: ; preds = %89
store i32 2, i32* %27
br label %205
205: ; preds = %236, %204
%206 = load i32, i32* %27
%207 = load i32, i32* %31
%208 = icmp sle i32 %206, %207
br i1 %208, label %209, label %239
209: ; preds = %205
store i32 1, i32* %28
br label %210
210: ; preds = %232, %209
%211 = load i32, i32* %28
%212 = load i32, i32* %27
%213 = icmp slt i32 %211, %212
br i1 %213, label %214, label %235
214: ; preds = %210
%215 = load float**, float*** %21
%216 = load i32, i32* %27
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds float*, float** %215, i64 %217
%219 = load float*, float** %218
%220 = load i32, i32* %28
%221 = sext i32 %220 to i64
%222 = getelementptr inbounds float, float* %219, i64 %221
%223 = load float, float* %222
%224 = load float**, float*** %21
%225 = load i32, i32* %28
%226 = sext i32 %225 to i64
%227 = getelementptr inbounds float*, float** %224, i64 %226
%228 = load float*, float** %227
%229 = load i32, i32* %27
%230 = sext i32 %229 to i64
%231 = getelementptr inbounds float, float* %228, i64 %230
store float %223, float* %231
br label %232
232: ; preds = %214
%233 = load i32, i32* %28
%234 = add nsw i32 %233, 1
store i32 %234, i32* %28
br label %210
235: ; preds = %210
br label %236
236: ; preds = %235
%237 = load i32, i32* %27
%238 = add nsw i32 %237, 1
store i32 %238, i32* %27
br label %205
239: ; preds = %205
%240 = load float*, float** %36
%241 = load i32, i32* %20
%242 = call i32 @free_fvector(float* %240, i32 1, i32 %241)
ret void
}

LLVM IR (-O2):
define void @mrqcofx(float* %0, i32 %1, float* nocapture %2, float* nocapture %3, i32 %4, float* %5, i32* nocapture %6, i32 %7, float** nocapture %8, float* nocapture %9, float* nocapture %10, void (float*, float*, float*, float*, i32)* nocapture %11) {
%13 = alloca float
%14 = bitcast float* %13 to i8*
%15 = tail call float* @fvector(i32 1, i32 %7)
%16 = icmp slt i32 %7, 1
br i1 %16, label %152, label %17
17: ; preds = %12
%18 = add nuw i32 %7, 1
%19 = zext i32 %18 to i64
%20 = add nsw i64 %19, -1
%21 = icmp ult i64 %20, 8
br i1 %21, label %94, label %22
22: ; preds = %17
%23 = and i64 %20, -8
%24 = or i64 %23, 1
%25 = add nsw i64 %23, -8
%26 = lshr exact i64 %25, 3
%27 = add nuw nsw i64 %26, 1
%28 = and i64 %27, 1
%29 = icmp eq i64 %25, 0
br i1 %29, label %68, label %30
30: ; preds = %22
%31 = and i64 %27, 4611686018427387902
br label %32
32: ; preds = %32, %30
%33 = phi i64 [ 0, %30 ], [ %63, %32 ]
%34 = phi <4 x i32> [ zeroinitializer, %30 ], [ %61, %32 ]
%35 = phi <4 x i32> [ zeroinitializer, %30 ], [ %62, %32 ]
%36 = phi i64 [ 0, %30 ], [ %64, %32 ]
%37 = or i64 %33, 1
%38 = getelementptr inbounds i32, i32* %6, i64 %37
%39 = bitcast i32* %38 to <4 x i32>*
%40 = load <4 x i32>, <4 x i32>* %39
%41 = getelementptr inbounds i32, i32* %38, i64 4
%42 = bitcast i32* %41 to <4 x i32>*
%43 = load <4 x i32>, <4 x i32>* %42
%44 = icmp ne <4 x i32> %40, zeroinitializer
%45 = icmp ne <4 x i32> %43, zeroinitializer
%46 = zext <4 x i1> %44 to <4 x i32>
%47 = zext <4 x i1> %45 to <4 x i32>
%48 = add <4 x i32> %34, %46
%49 = add <4 x i32> %35, %47
%50 = or i64 %33, 9
%51 = getelementptr inbounds i32, i32* %6, i64 %50
%52 = bitcast i32* %51 to <4 x i32>*
%53 = load <4 x i32>, <4 x i32>* %52
%54 = getelementptr inbounds i32, i32* %51, i64 4
%55 = bitcast i32* %54 to <4 x i32>*
%56 = load <4 x i32>, <4 x i32>* %55
%57 = icmp ne <4 x i32> %53, zeroinitializer
%58 = icmp ne <4 x i32> %56, zeroinitializer
%59 = zext <4 x i1> %57 to <4 x i32>
%60 = zext <4 x i1> %58 to <4 x i32>
%61 = add <4 x i32> %48, %59
%62 = add <4 x i32> %49, %60
%63 = add nuw i64 %33, 16
%64 = add i64 %36, 2
%65 = icmp eq i64 %64, %31
br i1 %65, label %66, label %32
66: ; preds = %32
%67 = or i64 %63, 1
br label %68
68: ; preds = %66, %22
%69 = phi <4 x i32> [ undef, %22 ], [ %61, %66 ]
%70 = phi <4 x i32> [ undef, %22 ], [ %62, %66 ]
%71 = phi i64 [ 1, %22 ], [ %67, %66 ]
%72 = phi <4 x i32> [ zeroinitializer, %22 ], [ %61, %66 ]
%73 = phi <4 x i32> [ zeroinitializer, %22 ], [ %62, %66 ]
%74 = icmp eq i64 %28, 0
br i1 %74, label %88, label %75
75: ; preds = %68
%76 = getelementptr inbounds i32, i32* %6, i64 %71
%77 = bitcast i32* %76 to <4 x i32>*
%78 = load <4 x i32>, <4 x i32>* %77
%79 = getelementptr inbounds i32, i32* %76, i64 4
%80 = bitcast i32* %79 to <4 x i32>*
%81 = load <4 x i32>, <4 x i32>* %80
%82 = icmp ne <4 x i32> %78, zeroinitializer
%83 = icmp ne <4 x i32> %81, zeroinitializer
%84 = zext <4 x i1> %82 to <4 x i32>
%85 = zext <4 x i1> %83 to <4 x i32>
%86 = add <4 x i32> %72, %84
%87 = add <4 x i32> %73, %85
br label %88
88: ; preds = %68, %75
%89 = phi <4 x i32> [ %69, %68 ], [ %86, %75 ]
%90 = phi <4 x i32> [ %70, %68 ], [ %87, %75 ]
%91 = add <4 x i32> %90, %89
%92 = call i32 @llvm.vector.reduce.add.v4i32(<4 x i32> %91)
%93 = icmp eq i64 %20, %23
br i1 %93, label %97, label %94
94: ; preds = %17, %88
%95 = phi i64 [ 1, %17 ], [ %24, %88 ]
%96 = phi i32 [ 0, %17 ], [ %92, %88 ]
br label %106
97: ; preds = %106, %88
%98 = phi i32 [ %92, %88 ], [ %113, %106 ]
%99 = icmp eq i32 %98, 0
br i1 %99, label %152, label %100
100: ; preds = %97
%101 = zext i32 %98 to i64
%102 = and i64 %101, 1
%103 = icmp eq i32 %98, 1
br i1 %103, label %142, label %104
104: ; preds = %100
%105 = and i64 %101, 4294967294
br label %116
106: ; preds = %94, %106
%107 = phi i64 [ %114, %106 ], [ %95, %94 ]
%108 = phi i32 [ %113, %106 ], [ %96, %94 ]
%109 = getelementptr inbounds i32, i32* %6, i64 %107
%110 = load i32, i32* %109
%111 = icmp ne i32 %110, 0
%112 = zext i1 %111 to i32
%113 = add nuw nsw i32 %108, %112
%114 = add nuw nsw i64 %107, 1
%115 = icmp eq i64 %114, %19
br i1 %115, label %97, label %106
116: ; preds = %116, %104
%117 = phi i64 [ 1, %104 ], [ %135, %116 ]
%118 = phi i64 [ 0, %104 ], [ %136, %116 ]
%119 = phi i64 [ 0, %104 ], [ %137, %116 ]
%120 = shl nuw nsw i64 %118, 2
%121 = or i64 %120, 4
%122 = getelementptr inbounds float*, float** %8, i64 %117
%123 = load float*, float** %122
%124 = getelementptr float, float* %123, i64 1
%125 = bitcast float* %124 to i8*
%126 = getelementptr inbounds float, float* %9, i64 %117
store float 0.000000e+00, float* %126
%127 = add nuw nsw i64 %117, 1
%128 = shl i64 %118, 2
%129 = add i64 %128, 8
%130 = getelementptr inbounds float*, float** %8, i64 %127
%131 = load float*, float** %130
%132 = getelementptr float, float* %131, i64 1
%133 = bitcast float* %132 to i8*
%134 = getelementptr inbounds float, float* %9, i64 %127
store float 0.000000e+00, float* %134
%135 = add nuw nsw i64 %117, 2
%136 = add nuw nsw i64 %118, 2
%137 = add i64 %119, 2
%138 = icmp eq i64 %137, %105
br i1 %138, label %139, label %116
139: ; preds = %116
%140 = shl i64 %136, 2
%141 = or i64 %140, 4
br label %142
142: ; preds = %139, %100
%143 = phi i64 [ 1, %100 ], [ %135, %139 ]
%144 = phi i64 [ 4, %100 ], [ %141, %139 ]
%145 = icmp eq i64 %102, 0
br i1 %145, label %152, label %146
146: ; preds = %142
%147 = getelementptr inbounds float*, float** %8, i64 %143
%148 = load float*, float** %147
%149 = getelementptr float, float* %148, i64 1
%150 = bitcast float* %149 to i8*
%151 = getelementptr inbounds float, float* %9, i64 %143
store float 0.000000e+00, float* %151
br label %152
152: ; preds = %146, %142, %12, %97
%153 = phi i32 [ 0, %97 ], [ 0, %12 ], [ %98, %142 ], [ %98, %146 ]
store float 0.000000e+00, float* %10
%154 = icmp slt i32 %4, 1
br i1 %154, label %161, label %155
155: ; preds = %152
%156 = add i32 %7, 1
%157 = sext i32 %1 to i64
%158 = add nuw i32 %4, 1
%159 = zext i32 %158 to i64
%160 = zext i32 %156 to i64
br label %166
161: ; preds = %220, %152
%162 = icmp ult i32 %153, 2
br i1 %162, label %284, label %163
163: ; preds = %161
%164 = add nuw i32 %153, 1
%165 = zext i32 %164 to i64
br label %227
166: ; preds = %155, %220
%167 = phi i64 [ 1, %155 ], [ %225, %220 ]
%168 = phi i64 [ 1, %155 ], [ %224, %220 ]
%169 = getelementptr inbounds float, float* %0, i64 %167
%170 = getelementptr inbounds float, float* %3, i64 %168
%171 = load float, float* %170
%172 = fmul float %171, %171
%173 = fdiv float 1.000000e+00, %172
%174 = getelementptr inbounds float, float* %2, i64 %168
%175 = load float, float* %174
%176 = load float, float* %13
%177 = fsub float %175, %176
br i1 %16, label %220, label %178
178: ; preds = %166, %215
%179 = phi i64 [ %217, %215 ], [ 1, %166 ]
%180 = phi i64 [ %218, %215 ], [ 2, %166 ]
%181 = phi i32 [ %216, %215 ], [ 0, %166 ]
%182 = getelementptr inbounds i32, i32* %6, i64 %179
%183 = load i32, i32* %182
%184 = icmp eq i32 %183, 0
br i1 %184, label %215, label %185
185: ; preds = %178
%186 = getelementptr inbounds float, float* %15, i64 %179
%187 = load float, float* %186
%188 = fmul float %173, %187
%189 = add nsw i32 %181, 1
%190 = sext i32 %189 to i64
%191 = getelementptr inbounds float*, float** %8, i64 %190
br label %192
192: ; preds = %185, %207
%193 = phi i64 [ 1, %185 ], [ %209, %207 ]
%194 = phi i32 [ 0, %185 ], [ %208, %207 ]
%195 = getelementptr inbounds i32, i32* %6, i64 %193
%196 = load i32, i32* %195
%197 = icmp eq i32 %196, 0
br i1 %197, label %207, label %198
198: ; preds = %192
%199 = getelementptr inbounds float, float* %15, i64 %193
%200 = load float, float* %199
%201 = load float*, float** %191
%202 = add nsw i32 %194, 1
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds float, float* %201, i64 %203
%205 = load float, float* %204
%206 = call float @llvm.fmuladd.f32(float %188, float %200, float %205)
store float %206, float* %204
br label %207
207: ; preds = %192, %198
%208 = phi i32 [ %202, %198 ], [ %194, %192 ]
%209 = add nuw nsw i64 %193, 1
%210 = icmp eq i64 %209, %180
br i1 %210, label %211, label %192
211: ; preds = %207
%212 = getelementptr inbounds float, float* %9, i64 %190
%213 = load float, float* %212
%214 = call float @llvm.fmuladd.f32(float %177, float %188, float %213)
store float %214, float* %212
br label %215
215: ; preds = %178, %211
%216 = phi i32 [ %189, %211 ], [ %181, %178 ]
%217 = add nuw nsw i64 %179, 1
%218 = add nuw nsw i64 %180, 1
%219 = icmp eq i64 %217, %160
br i1 %219, label %220, label %178
220: ; preds = %215, %166
%221 = fmul float %177, %177
%222 = load float, float* %10
%223 = call float @llvm.fmuladd.f32(float %221, float %173, float %222)
store float %223, float* %10
%224 = add nuw nsw i64 %168, 1
%225 = add nsw i64 %167, %157
%226 = icmp eq i64 %224, %159
br i1 %226, label %161, label %166
227: ; preds = %163, %280
%228 = phi i64 [ 0, %163 ], [ %283, %280 ]
%229 = phi i64 [ 2, %163 ], [ %281, %280 ]
%230 = add i64 %228, 1
%231 = getelementptr inbounds float*, float** %8, i64 %229
%232 = load float*, float** %231
%233 = and i64 %230, 3
%234 = icmp ult i64 %228, 3
br i1 %234, label %266, label %235
235: ; preds = %227
%236 = and i64 %230, -4
br label %237
237: ; preds = %237, %235
%238 = phi i64 [ 1, %235 ], [ %263, %237 ]
%239 = phi i64 [ 0, %235 ], [ %264, %237 ]
%240 = getelementptr inbounds float, float* %232, i64 %238
%241 = load float, float* %240
%242 = getelementptr inbounds float*, float** %8, i64 %238
%243 = load float*, float** %242
%244 = getelementptr inbounds float, float* %243, i64 %229
store float %241, float* %244
%245 = add nuw nsw i64 %238, 1
%246 = getelementptr inbounds float, float* %232, i64 %245
%247 = load float, float* %246
%248 = getelementptr inbounds float*, float** %8, i64 %245
%249 = load float*, float** %248
%250 = getelementptr inbounds float, float* %249, i64 %229
store float %247, float* %250
%251 = add nuw nsw i64 %238, 2
%252 = getelementptr inbounds float, float* %232, i64 %251
%253 = load float, float* %252
%254 = getelementptr inbounds float*, float** %8, i64 %251
%255 = load float*, float** %254
%256 = getelementptr inbounds float, float* %255, i64 %229
store float %253, float* %256
%257 = add nuw nsw i64 %238, 3
%258 = getelementptr inbounds float, float* %232, i64 %257
%259 = load float, float* %258
%260 = getelementptr inbounds float*, float** %8, i64 %257
%261 = load float*, float** %260
%262 = getelementptr inbounds float, float* %261, i64 %229
store float %259, float* %262
%263 = add nuw nsw i64 %238, 4
%264 = add i64 %239, 4
%265 = icmp eq i64 %264, %236
br i1 %265, label %266, label %237
266: ; preds = %237, %227
%267 = phi i64 [ 1, %227 ], [ %263, %237 ]
%268 = icmp eq i64 %233, 0
br i1 %268, label %280, label %269
269: ; preds = %266, %269
%270 = phi i64 [ %277, %269 ], [ %267, %266 ]
%271 = phi i64 [ %278, %269 ], [ 0, %266 ]
%272 = getelementptr inbounds float, float* %232, i64 %270
%273 = load float, float* %272
%274 = getelementptr inbounds float*, float** %8, i64 %270
%275 = load float*, float** %274
%276 = getelementptr inbounds float, float* %275, i64 %229
store float %273, float* %276
%277 = add nuw nsw i64 %270, 1
%278 = add i64 %271, 1
%279 = icmp eq i64 %278, %233
br i1 %279, label %280, label %269
280: ; preds = %269, %266
%281 = add nuw nsw i64 %229, 1
%282 = icmp eq i64 %281, %165
%283 = add i64 %228, 1
br i1 %282, label %284, label %227
284: ; preds = %280, %161
%285 = call i32 @free_fvector(float* %15, i32 1, i32 %7)
ret void
}