#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 */
float sqrt(float);
void fit(float x[], float y[], int ndata, float sig[], int mwt, float *a,
         float *b, float *siga, float *sigb, float *chi2, float *q,
         float *lcc) {
  float gammq(float a, float x);
  int i;
  float wt, t, sxoss, sx = 0.0, sy = 0.0, st2 = 0.0, ss, sigdat;
  *b = 0;
  if (mwt) {
    ss = 0.0;
    for (i = 1; i <= ndata; i++) {
      wt = 1.0 / (sig[i] * sig[i]);
      ss += wt;
      sx += x[i] * wt;
      sy += y[i] * wt;
    }
  } else {
    for (i = 1; i <= ndata; i++) {
      sx += x[i];
      sy += y[i];
    }
    ss = ndata;
  }
  sxoss = sx / ss;
  if (mwt) {
    for (i = 1; i <= ndata; i++) {
      t = (x[i] - sxoss) / sig[i];
      st2 += t * t;
      *b += t * y[i] / sig[i];
    }
  } else {
    for (i = 1; i <= ndata; i++) {
      t = x[i] - sxoss;
      st2 += t * t;
      *b += t * y[i];
    }
  }
  *b /= st2;
  *a = (sy - sx * (*b)) / ss;
  *siga = sqrt((1.0 + sx * sx / (ss * st2)) / ss);
  *sigb = sqrt(1.0 / st2);
  *lcc = -sx / (ss * st2 * (*siga) * (*sigb));
  *chi2 = 0.0;
  if (mwt == 0) {
    for (i = 1; i <= ndata; i++)
      *chi2 += (y[i] - (*a) - (*b) * x[i]) * (y[i] - (*a) - (*b) * x[i]);
    *q = 1.0;
    sigdat = sqrt((*chi2) / (ndata - 2));
    *siga *= sigdat;
    *sigb *= sigdat;
  } else {
    for (i = 1; i <= ndata; i++)
      *chi2 += ((y[i] - (*a) - (*b) * x[i]) / sig[i]) *
               ((y[i] - (*a) - (*b) * x[i]) / sig[i]);
    *q = gammq(0.5 * (ndata - 2), 0.5 * (*chi2));
  }
}


x86 assembly (clang, -O0):
<fit>:
push   %rbp
mov    %rsp,%rbp
sub    $0x60,%rsp
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8d,-0x24(%rbp)
mov    %r9,-0x30(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x44(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x48(%rbp)
xorps  %xmm0,%xmm0
movss  %xmm0,-0x4c(%rbp)
mov    0x10(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
cmpl   $0x0,-0x24(%rbp)
je     123c <fit+0x11c>
xorps  %xmm0,%xmm0
movss  %xmm0,-0x50(%rbp)
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1237 <fit+0x117>
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  0xe3b(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
movss  %xmm0,-0x38(%rbp)
movss  -0x38(%rbp),%xmm0
addss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x44(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
movss  -0x38(%rbp),%xmm2
movss  -0x48(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1193 <fit+0x73>
jmp    1295 <fit+0x175>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     128b <fit+0x16b>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x44(%rbp),%xmm0
movss  %xmm0,-0x44(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
addss  -0x48(%rbp),%xmm0
movss  %xmm0,-0x48(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1243 <fit+0x123>
cvtsi2ssl -0x14(%rbp),%xmm0
movss  %xmm0,-0x50(%rbp)
movss  -0x44(%rbp),%xmm0
divss  -0x50(%rbp),%xmm0
movss  %xmm0,-0x40(%rbp)
cmpl   $0x0,-0x24(%rbp)
je     133f <fit+0x21f>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     133a <fit+0x21a>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x40(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulss  (%rax,%rcx,4),%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
mov    0x10(%rbp),%rax
addss  (%rax),%xmm0
movss  %xmm0,(%rax)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12b5 <fit+0x195>
jmp    13be <fit+0x29e>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     13b9 <fit+0x299>
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm0
subss  -0x40(%rbp),%xmm0
movss  %xmm0,-0x3c(%rbp)
movss  -0x3c(%rbp),%xmm0
movss  -0x3c(%rbp),%xmm2
movss  -0x4c(%rbp),%xmm1
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,-0x4c(%rbp)
movss  -0x3c(%rbp),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
mov    0x10(%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)
jmp    1346 <fit+0x226>
jmp    13be <fit+0x29e>
movss  -0x4c(%rbp),%xmm1
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
divss  %xmm1,%xmm0
movss  %xmm0,(%rax)
movss  -0x48(%rbp),%xmm1
movss  -0x44(%rbp),%xmm0
mov    0x10(%rbp),%rax
movss  (%rax),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
divss  -0x50(%rbp),%xmm0
mov    -0x30(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x44(%rbp),%xmm0
mulss  -0x44(%rbp),%xmm0
movss  -0x50(%rbp),%xmm1
mulss  -0x4c(%rbp),%xmm1
divss  %xmm1,%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xbd5(%rip),%xmm0
addsd  %xmm1,%xmm0
movss  -0x50(%rbp),%xmm1
cvtss2sd %xmm1,%xmm1
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1040 <sqrt@plt>
mov    0x18(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x4c(%rbp),%xmm0
cvtss2sd %xmm0,%xmm1
movsd  0xba2(%rip),%xmm0
divsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
call   1040 <sqrt@plt>
mov    0x20(%rbp),%rax
movss  %xmm0,(%rax)
movss  -0x44(%rbp),%xmm0
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
movss  -0x50(%rbp),%xmm1
mulss  -0x4c(%rbp),%xmm1
mov    0x18(%rbp),%rax
mulss  (%rax),%xmm1
mov    0x20(%rbp),%rax
mulss  (%rax),%xmm1
divss  %xmm1,%xmm0
mov    0x38(%rbp),%rax
movss  %xmm0,(%rax)
mov    0x28(%rbp),%rax
xorps  %xmm0,%xmm0
movss  %xmm0,(%rax)
cmpl   $0x0,-0x24(%rbp)
jne    15ca <fit+0x4aa>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1573 <fit+0x453>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x30(%rbp),%rax
subss  (%rax),%xmm1
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x30(%rbp),%rax
subss  (%rax),%xmm1
mov    0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
mov    0x28(%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)
jmp    14c7 <fit+0x3a7>
mov    0x30(%rbp),%rax
movss  0xa91(%rip),%xmm0
movss  %xmm0,(%rax)
mov    0x28(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
cvtsi2ss %eax,%xmm1
divss  %xmm1,%xmm0
call   1040 <sqrt@plt>
movss  %xmm0,-0x54(%rbp)
movss  -0x54(%rbp),%xmm0
mov    0x18(%rbp),%rax
mulss  (%rax),%xmm0
movss  %xmm0,(%rax)
movss  -0x54(%rbp),%xmm0
mov    0x20(%rbp),%rax
mulss  (%rax),%xmm0
movss  %xmm0,(%rax)
jmp    16da <fit+0x5ba>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x14(%rbp),%eax
jg     1697 <fit+0x577>
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x30(%rbp),%rax
subss  (%rax),%xmm1
mov    0x10(%rbp),%rax
movss  (%rax),%xmm0
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm2
movd   %xmm0,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm0
mulss  %xmm2,%xmm0
addss  %xmm1,%xmm0
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm0
mov    -0x10(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm1
mov    -0x30(%rbp),%rax
subss  (%rax),%xmm1
mov    0x10(%rbp),%rax
movss  (%rax),%xmm2
mov    -0x8(%rbp),%rax
movslq -0x34(%rbp),%rcx
movss  (%rax,%rcx,4),%xmm3
movd   %xmm2,%eax
xor    $0x80000000,%eax
movd   %eax,%xmm2
mulss  %xmm3,%xmm2
addss  %xmm1,%xmm2
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
divss  (%rax,%rcx,4),%xmm2
mov    0x28(%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)
jmp    15d1 <fit+0x4b1>
mov    -0x14(%rbp),%eax
sub    $0x2,%eax
cvtsi2sd %eax,%xmm1
movsd  0x95f(%rip),%xmm0
mulsd  %xmm1,%xmm0
cvtsd2ss %xmm0,%xmm0
mov    0x28(%rbp),%rax
movss  (%rax),%xmm1
cvtss2sd %xmm1,%xmm2
movsd  0x943(%rip),%xmm1
mulsd  %xmm2,%xmm1
cvtsd2ss %xmm1,%xmm1
call   1030 <gammq@plt>
mov    0x30(%rbp),%rax
movss  %xmm0,(%rax)
add    $0x60,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<fit>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x38,%rsp
mov    %r9,%r15
mov    %rcx,%r13
mov    %rsi,%rbx
mov    %rdi,%r12
mov    0x70(%rsp),%rbp
movl   $0x0,0x0(%rbp)
test   %r8d,%r8d
je     11b5 <fit+0x95>
test   %edx,%edx
jle    11e0 <fit+0xc0>
lea    0x1(%rdx),%eax
xorps  %xmm3,%xmm3
xorps  %xmm6,%xmm6
mov    $0x1,%ecx
movss  0xe97(%rip),%xmm0
nopl   0x0(%rax)
movaps %xmm3,%xmm2
movss  0x0(%r13,%rcx,4),%xmm3
mulss  %xmm3,%xmm3
movaps %xmm0,%xmm1
divss  %xmm3,%xmm1
addss  %xmm1,%xmm6
movss  (%r12,%rcx,4),%xmm3
movss  (%rbx,%rcx,4),%xmm4
unpcklps %xmm3,%xmm4
shufps $0x0,%xmm1,%xmm1
mulps  %xmm4,%xmm1
movaps %xmm1,%xmm3
addps  %xmm2,%xmm3
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1170 <fit+0x50>
addps  %xmm2,%xmm1
jmp    128d <fit+0x16d>
test   %edx,%edx
jle    11eb <fit+0xcb>
mov    %edx,%esi
lea    -0x1(%rsi),%rcx
mov    %esi,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
jae    11f3 <fit+0xd3>
xorps  %xmm1,%xmm1
mov    $0x1,%ecx
test   %rax,%rax
jne    125e <fit+0x13e>
jmp    1289 <fit+0x169>
xorps  %xmm1,%xmm1
xorps  %xmm6,%xmm6
jmp    130d <fit+0x1ed>
xorps  %xmm1,%xmm1
jmp    1289 <fit+0x169>
and    $0xfffffffc,%esi
xorps  %xmm1,%xmm1
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
movss  0x4(%r12,%rcx,4),%xmm0
movss  0x8(%r12,%rcx,4),%xmm2
movss  0xc(%r12,%rcx,4),%xmm3
movss  0x10(%r12,%rcx,4),%xmm4
movss  0x4(%rbx,%rcx,4),%xmm5
unpcklps %xmm0,%xmm5
addps  %xmm1,%xmm5
movss  0x8(%rbx,%rcx,4),%xmm0
unpcklps %xmm2,%xmm0
addps  %xmm5,%xmm0
movss  0xc(%rbx,%rcx,4),%xmm2
unpcklps %xmm3,%xmm2
addps  %xmm0,%xmm2
movss  0x10(%rbx,%rcx,4),%xmm1
unpcklps %xmm4,%xmm1
addps  %xmm2,%xmm1
add    $0x4,%rcx
cmp    %rcx,%rsi
jne    1200 <fit+0xe0>
add    $0x1,%rcx
test   %rax,%rax
je     1289 <fit+0x169>
lea    (%rbx,%rcx,4),%rdi
lea    (%r12,%rcx,4),%rcx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movss  (%rcx,%rsi,4),%xmm0
movss  (%rdi,%rsi,4),%xmm2
unpcklps %xmm0,%xmm2
addps  %xmm2,%xmm1
add    $0x1,%rsi
cmp    %rsi,%rax
jne    1270 <fit+0x150>
cvtsi2ss %edx,%xmm6
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
divss  %xmm6,%xmm2
test   %r8d,%r8d
je     12ed <fit+0x1cd>
test   %edx,%edx
jle    130d <fit+0x1ed>
lea    0x1(%rdx),%eax
mov    $0x1,%ecx
xorps  %xmm0,%xmm0
xorps  %xmm7,%xmm7
nop
movss  (%r12,%rcx,4),%xmm3
subss  %xmm2,%xmm3
movss  0x0(%r13,%rcx,4),%xmm4
divss  %xmm4,%xmm3
movaps %xmm3,%xmm5
mulss  %xmm3,%xmm5
addss  %xmm5,%xmm7
mulss  (%rbx,%rcx,4),%xmm3
divss  %xmm4,%xmm3
addss  %xmm3,%xmm0
movss  %xmm0,0x0(%rbp)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    12b0 <fit+0x190>
jmp    1313 <fit+0x1f3>
test   %edx,%edx
jle    130d <fit+0x1ed>
mov    %edx,%eax
cmp    $0x1,%edx
jne    15da <fit+0x4ba>
xorps  %xmm0,%xmm0
mov    $0x1,%ecx
test   $0x1,%al
je     1313 <fit+0x1f3>
jmp    1655 <fit+0x535>
xorps  %xmm0,%xmm0
xorps  %xmm7,%xmm7
divss  %xmm7,%xmm0
movss  %xmm0,0x0(%rbp)
movaps %xmm1,%xmm2
shufps $0x55,%xmm1,%xmm2
movaps 0xce6(%rip),%xmm3
xorps  %xmm2,%xmm3
mulss  %xmm2,%xmm0
subss  %xmm0,%xmm1
divss  %xmm6,%xmm1
mulss  %xmm2,%xmm2
xorps  %xmm0,%xmm0
cvtss2sd %xmm6,%xmm0
mulss  %xmm7,%xmm6
divss  %xmm6,%xmm2
cvtss2sd %xmm2,%xmm2
addsd  0xcc8(%rip),%xmm2
mov    0x78(%rsp),%r9
divsd  %xmm0,%xmm2
xorps  %xmm0,%xmm0
cvtsd2ss %xmm2,%xmm0
movss  %xmm1,(%r15)
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
mov    %r8d,0x4(%rsp)
movss  %xmm6,(%rsp)
mov    %rdx,0x8(%rsp)
movaps %xmm3,0x10(%rsp)
jb     138f <fit+0x26f>
sqrtss %xmm0,%xmm0
jmp    13a7 <fit+0x287>
mov    %r9,%rbp
movaps %xmm7,0x20(%rsp)
call   1040 <sqrt@plt>
xorps  %xmm1,%xmm1
movaps 0x20(%rsp),%xmm7
mov    %rbp,%r9
mov    0x98(%rsp),%rcx
mov    0x88(%rsp),%r14
mov    0x80(%rsp),%r10
movss  %xmm0,(%r9)
movss  0xc34(%rip),%xmm0
divss  %xmm7,%xmm0
ucomiss %xmm1,%xmm0
jb     13db <fit+0x2bb>
sqrtss %xmm0,%xmm0
jmp    13f6 <fit+0x2d6>
mov    %r9,%rbp
call   1040 <sqrt@plt>
mov    0x98(%rsp),%rcx
mov    0x80(%rsp),%r10
mov    %rbp,%r9
mov    0x8(%rsp),%rdi
mov    0x70(%rsp),%rbp
mov    0x4(%rsp),%eax
movss  (%rsp),%xmm1
movaps 0x10(%rsp),%xmm2
mov    0x90(%rsp),%r8
movss  %xmm0,(%r10)
mulss  (%r9),%xmm1
mulss  %xmm0,%xmm1
divss  %xmm1,%xmm2
movss  %xmm2,(%rcx)
movl   $0x0,(%r14)
test   %eax,%eax
je     1490 <fit+0x370>
test   %edi,%edi
jle    14ac <fit+0x38c>
lea    0x1(%rdi),%eax
mov    $0x1,%ecx
xorps  %xmm1,%xmm1
cs nopw 0x0(%rax,%rax,1)
movss  (%rbx,%rcx,4),%xmm0
subss  (%r15),%xmm0
movss  0x0(%rbp),%xmm2
mulss  (%r12,%rcx,4),%xmm2
subss  %xmm2,%xmm0
divss  0x0(%r13,%rcx,4),%xmm0
mulss  %xmm0,%xmm0
addss  %xmm0,%xmm1
movss  %xmm1,(%r14)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    1450 <fit+0x330>
mulss  0xb76(%rip),%xmm1
jmp    14af <fit+0x38f>
test   %edi,%edi
jle    157a <fit+0x45a>
mov    %edi,%eax
cmp    $0x1,%edi
jne    14db <fit+0x3bb>
mov    $0x1,%ecx
xorps  %xmm0,%xmm0
jmp    1550 <fit+0x430>
xorps  %xmm1,%xmm1
add    $0xfffffffe,%edi
xorps  %xmm0,%xmm0
cvtsi2sd %edi,%xmm0
mulsd  0xb67(%rip),%xmm0
cvtsd2ss %xmm0,%xmm0
call   1030 <gammq@plt>
mov    0x90(%rsp),%rax
movss  %xmm0,(%rax)
jmp    15cb <fit+0x4ab>
mov    %eax,%edx
and    $0xfffffffe,%edx
neg    %rdx
mov    $0x1,%ecx
xorps  %xmm0,%xmm0
nopl   0x0(%rax,%rax,1)
movss  (%rbx,%rcx,4),%xmm1
subss  (%r15),%xmm1
movss  0x0(%rbp),%xmm2
mulss  (%r12,%rcx,4),%xmm2
subss  %xmm2,%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%r14)
movss  0x4(%rbx,%rcx,4),%xmm0
subss  (%r15),%xmm0
movss  0x0(%rbp),%xmm2
mulss  0x4(%r12,%rcx,4),%xmm2
subss  %xmm2,%xmm0
mulss  %xmm0,%xmm0
addss  %xmm1,%xmm0
movss  %xmm0,(%r14)
lea    (%rdx,%rcx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rcx
cmp    $0x1,%rsi
jne    14f0 <fit+0x3d0>
test   $0x1,%al
je     157a <fit+0x45a>
movss  (%rbx,%rcx,4),%xmm1
subss  (%r15),%xmm1
movss  0x0(%rbp),%xmm2
mulss  (%r12,%rcx,4),%xmm2
subss  %xmm2,%xmm1
mulss  %xmm1,%xmm1
addss  %xmm0,%xmm1
movss  %xmm1,(%r14)
movl   $0x3f800000,(%r8)
movss  (%r14),%xmm0
add    $0xfffffffe,%edi
xorps  %xmm1,%xmm1
cvtsi2ss %edi,%xmm1
divss  %xmm1,%xmm0
xorps  %xmm1,%xmm1
ucomiss %xmm1,%xmm0
jb     15a2 <fit+0x482>
sqrtss %xmm0,%xmm0
jmp    15b3 <fit+0x493>
mov    %r9,%rbx
mov    %r10,%rbp
call   1040 <sqrt@plt>
mov    %rbp,%r10
mov    %rbx,%r9
movss  (%r9),%xmm1
mulss  %xmm0,%xmm1
movss  %xmm1,(%r9)
mulss  (%r10),%xmm0
movss  %xmm0,(%r10)
add    $0x38,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %eax,%edi
and    $0xfffffffe,%edi
neg    %rdi
xorps  %xmm0,%xmm0
mov    $0x1,%ecx
nopw   0x0(%rax,%rax,1)
movss  (%r12,%rcx,4),%xmm3
subss  %xmm2,%xmm3
movss  (%rbx,%rcx,4),%xmm4
unpcklps %xmm3,%xmm4
shufps $0x0,%xmm3,%xmm3
mulps  %xmm4,%xmm3
addps  %xmm0,%xmm3
movss  %xmm3,0x0(%rbp)
movss  0x4(%r12,%rcx,4),%xmm0
subss  %xmm2,%xmm0
movss  0x4(%rbx,%rcx,4),%xmm4
unpcklps %xmm0,%xmm4
shufps $0x0,%xmm0,%xmm0
mulps  %xmm4,%xmm0
addps  %xmm3,%xmm0
movss  %xmm0,0x0(%rbp)
lea    (%rdi,%rcx,1),%rsi
add    $0x2,%rsi
add    $0x2,%rcx
cmp    $0x1,%rsi
jne    15f0 <fit+0x4d0>
movaps %xmm0,%xmm7
shufps $0x55,%xmm0,%xmm7
test   $0x1,%al
je     1313 <fit+0x1f3>
movss  (%r12,%rcx,4),%xmm3
subss  %xmm2,%xmm3
movss  (%rbx,%rcx,4),%xmm2
unpcklps %xmm3,%xmm2
shufps $0x0,%xmm3,%xmm3
mulps  %xmm2,%xmm3
addps  %xmm3,%xmm0
movss  %xmm0,0x0(%rbp)
movaps %xmm0,%xmm7
shufps $0x55,%xmm0,%xmm7
jmp    1313 <fit+0x1f3>

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

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