void palFitxy(int itype, int np, double xye[][2], double xym[][2],
              double coeffs[6], int *j) {
  int i, jstat, iw[4], nsol;
  double a, b, c, d, aold, bold, cold, dold, sold, p, sxe, sxexm, sxeym, sye,
      syeym, syexm, sxm, sym, sxmxm, sxmym, symym, xe, ye, xm, ym, v[4],
      dm3[3][3], dm4[4][4], det, sgn, sxxyy, sxyyx, sx2y2, sdr2, xr, yr;
  *j = 0;
  a = 0.0;
  b = 0.0;
  c = 0.0;
  d = 0.0;
  aold = 0.0;
  bold = 0.0;
  cold = 0.0;
  dold = 0.0;
  sold = 0.0;
  p = (double)np;
  if (itype == 6) {
    if (np >= 3) {
      sxe = 0.0;
      sxexm = 0.0;
      sxeym = 0.0;
      sye = 0.0;
      syeym = 0.0;
      syexm = 0.0;
      sxm = 0.0;
      sym = 0.0;
      sxmxm = 0.0;
      sxmym = 0.0;
      symym = 0.0;
      for (i = 0; i < np; i++) {
        xe = xye[i][0];
        ye = xye[i][1];
        xm = xym[i][0];
        ym = xym[i][1];
        sxe = sxe + xe;
        sxexm = sxexm + xe * xm;
        sxeym = sxeym + xe * ym;
        sye = sye + ye;
        syeym = syeym + ye * ym;
        syexm = syexm + ye * xm;
        sxm = sxm + xm;
        sym = sym + ym;
        sxmxm = sxmxm + xm * xm;
        sxmym = sxmym + xm * ym;
        symym = symym + ym * ym;
      }
      v[0] = sxe;
      v[1] = sxexm;
      v[2] = sxeym;
      dm3[0][0] = p;
      dm3[0][1] = sxm;
      dm3[0][2] = sym;
      dm3[1][0] = sxm;
      dm3[1][1] = sxmxm;
      dm3[1][2] = sxmym;
      dm3[2][0] = sym;
      dm3[2][1] = sxmym;
      dm3[2][2] = symym;
      palDmat(3, *dm3, v, &det, &jstat, iw);
      if (jstat == 0) {
        for (i = 0; i < 3; i++) {
          coeffs[i] = v[i];
        }
        v[0] = sye;
        v[1] = syexm;
        v[2] = syeym;
        palDmxv(dm3, v, coeffs + 3);
      } else {
        *j = -3;
      }
    } else {
      *j = -2;
    }
  } else if (itype == 4) {
    if (np >= 2) {
      for (nsol = 0; nsol < 2; nsol++) {
        if (nsol == 0) {
          sgn = 1.0;
        } else {
          sgn = -1.0;
        }
        sxe = 0.0;
        sxxyy = 0.0;
        sxyyx = 0.0;
        sye = 0.0;
        sxm = 0.0;
        sym = 0.0;
        sx2y2 = 0.0;
        for (i = 0; i < np; i++) {
          xe = xye[i][0] * sgn;
          ye = xye[i][1];
          xm = xym[i][0];
          ym = xym[i][1];
          sxe = sxe + xe;
          sxxyy = sxxyy + xe * xm + ye * ym;
          sxyyx = sxyyx + xe * ym - ye * xm;
          sye = sye + ye;
          sxm = sxm + xm;
          sym = sym + ym;
          sx2y2 = sx2y2 + xm * xm + ym * ym;
        }
        v[0] = sxe;
        v[1] = sxxyy;
        v[2] = sxyyx;
        v[3] = sye;
        dm4[0][0] = p;
        dm4[0][1] = sxm;
        dm4[0][2] = -sym;
        dm4[0][3] = 0.0;
        dm4[1][0] = sxm;
        dm4[1][1] = sx2y2;
        dm4[1][2] = 0.0;
        dm4[1][3] = sym;
        dm4[2][0] = sym;
        dm4[2][1] = 0.0;
        dm4[2][2] = -sx2y2;
        dm4[2][3] = -sxm;
        dm4[3][0] = 0.0;
        dm4[3][1] = sym;
        dm4[3][2] = sxm;
        dm4[3][3] = p;
        palDmat(4, *dm4, v, &det, &jstat, iw);
        if (jstat == 0) {
          a = v[0];
          b = v[1];
          c = v[2];
          d = v[3];
          sdr2 = 0.0;
          for (i = 0; i < np; i++) {
            xm = xym[i][0];
            ym = xym[i][1];
            xr = a + b * xm - c * ym - xye[i][0] * sgn;
            yr = d + c * xm + b * ym - xye[i][1];
            sdr2 = sdr2 + xr * xr + yr * yr;
          }
        } else {
          sdr2 = -1.0;
        }
        if (nsol == 0 && jstat == 0) {
          aold = a;
          bold = b;
          cold = c;
          dold = d;
          sold = sdr2;
        }
      }
      if (sold >= 0.0 && (sold <= sdr2 || np == 2)) {
        coeffs[0] = aold;
        coeffs[1] = bold;
        coeffs[2] = -cold;
        coeffs[3] = dold;
        coeffs[4] = cold;
        coeffs[5] = bold;
      } else if (jstat == 0) {
        coeffs[0] = -a;
        coeffs[1] = -b;
        coeffs[2] = c;
        coeffs[3] = d;
        coeffs[4] = c;
        coeffs[5] = b;
      } else {
        *j = -3;
      }
    } else {
      *j = -2;
    }
  } else {
    *j = -1;
  }
}


x86 assembly (clang, -O0):
<palFitxy>:
push   %rbp
mov    %rsp,%rbp
sub    $0x240,%rsp
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
mov    %r8,-0x20(%rbp)
mov    %r9,-0x28(%rbp)
mov    -0x28(%rbp),%rax
movl   $0x0,(%rax)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x58(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x60(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x70(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
cvtsi2sdl -0x8(%rbp),%xmm0
movsd  %xmm0,-0x98(%rbp)
ff
cmpl   $0x6,-0x4(%rbp)
jne    15d6 <palFitxy+0x4b6>
cmpl   $0x3,-0x8(%rbp)
jl     15c7 <palFitxy+0x4a7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    143a <palFitxy+0x31a>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0xa8(%rbp),%xmm1
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
movsd  -0xb0(%rbp),%xmm1
ff
movsd  -0xf8(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
addsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xc0(%rbp),%xmm1
ff
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movsd  -0xc8(%rbp),%xmm1
ff
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
addsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0xe0(%rbp),%xmm1
ff
movsd  -0x108(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe0(%rbp)
ff
movsd  -0xe8(%rbp),%xmm1
ff
movsd  -0x108(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xe8(%rbp)
ff
movsd  -0xf0(%rbp),%xmm1
ff
movsd  -0x110(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xf0(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    123a <palFitxy+0x11a>
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xa8(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x180(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x178(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x170(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x168(%rbp)
ff
movsd  -0xe0(%rbp),%xmm0
ff
movsd  %xmm0,-0x160(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0x158(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x150(%rbp)
ff
movsd  -0xe8(%rbp),%xmm0
ff
movsd  %xmm0,-0x148(%rbp)
ff
movsd  -0xf0(%rbp),%xmm0
ff
movsd  %xmm0,-0x140(%rbp)
ff
lea    -0x180(%rbp),%rsi
lea    -0x130(%rbp),%rdx
lea    -0x40(%rbp),%r9
mov    $0x3,%edi
lea    -0x208(%rbp),%rcx
lea    -0x30(%rbp),%r8
mov    $0x0,%al
call   1030 <palDmat@plt>
cmpl   $0x0,-0x30(%rbp)
jne    15b8 <palFitxy+0x498>
movl   $0x0,-0x2c(%rbp)
cmpl   $0x3,-0x2c(%rbp)
jge    1566 <palFitxy+0x446>
movslq -0x2c(%rbp),%rax
movsd  -0x130(%rbp,%rax,8),%xmm0
ff ff
mov    -0x20(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1534 <palFitxy+0x414>
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0xc8(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0xc0(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
lea    -0x180(%rbp),%rdi
lea    -0x130(%rbp),%rsi
mov    -0x20(%rbp),%rdx
add    $0x18,%rdx
mov    $0x0,%al
call   1040 <palDmxv@plt>
jmp    15c2 <palFitxy+0x4a2>
mov    -0x28(%rbp),%rax
movl   $0xfffffffd,(%rax)
jmp    15d1 <palFitxy+0x4b1>
mov    -0x28(%rbp),%rax
movl   $0xfffffffe,(%rax)
jmp    1d77 <palFitxy+0xc57>
cmpl   $0x4,-0x4(%rbp)
jne    1d68 <palFitxy+0xc48>
cmpl   $0x2,-0x8(%rbp)
jl     1d59 <palFitxy+0xc39>
movl   $0x0,-0x44(%rbp)
cmpl   $0x2,-0x44(%rbp)
jge    1c0a <palFitxy+0xaea>
cmpl   $0x0,-0x44(%rbp)
jne    161a <palFitxy+0x4fa>
movsd  0x9fb(%rip),%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
jmp    162a <palFitxy+0x50a>
movsd  0x9de(%rip),%xmm0
movsd  %xmm0,-0x210(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xd8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1845 <palFitxy+0x725>
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
mulsd  -0x210(%rbp),%xmm0
ff
movsd  %xmm0,-0xf8(%rbp)
ff
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x100(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0xa0(%rbp),%xmm0
ff
addsd  -0xf8(%rbp),%xmm0
ff
movsd  %xmm0,-0xa0(%rbp)
ff
movsd  -0x218(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm1
ff
movsd  -0x108(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x218(%rbp)
ff
movsd  -0x220(%rbp),%xmm0
ff
movsd  -0xf8(%rbp),%xmm1
ff
movsd  -0x110(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x100(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x220(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
addsd  -0x100(%rbp),%xmm0
ff
movsd  %xmm0,-0xb8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
addsd  -0x108(%rbp),%xmm0
ff
movsd  %xmm0,-0xd0(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
addsd  -0x110(%rbp),%xmm0
ff
movsd  %xmm0,-0xd8(%rbp)
ff
movsd  -0x228(%rbp),%xmm0
ff
movsd  -0x108(%rbp),%xmm1
ff
movsd  -0x108(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x110(%rbp),%xmm0
ff
movsd  -0x110(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x228(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    167e <palFitxy+0x55e>
movsd  -0xa0(%rbp),%xmm0
ff
movsd  %xmm0,-0x130(%rbp)
ff
movsd  -0x218(%rbp),%xmm0
ff
movsd  %xmm0,-0x128(%rbp)
ff
movsd  -0x220(%rbp),%xmm0
ff
movsd  %xmm0,-0x120(%rbp)
ff
movsd  -0xb8(%rbp),%xmm0
ff
movsd  %xmm0,-0x118(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x200(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1f8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x1f0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1e8(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x1e0(%rbp)
ff
movsd  -0x228(%rbp),%xmm0
ff
movsd  %xmm0,-0x1d8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1d0(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c8(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x1c0(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1b8(%rbp)
ff
movsd  -0x228(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x1b0(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
movsd  %xmm0,-0x1a8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x1a0(%rbp)
ff
movsd  -0xd8(%rbp),%xmm0
ff
movsd  %xmm0,-0x198(%rbp)
ff
movsd  -0xd0(%rbp),%xmm0
ff
movsd  %xmm0,-0x190(%rbp)
ff
movsd  -0x98(%rbp),%xmm0
ff
movsd  %xmm0,-0x188(%rbp)
ff
lea    -0x200(%rbp),%rsi
lea    -0x130(%rbp),%rdx
lea    -0x40(%rbp),%r9
mov    $0x4,%edi
lea    -0x208(%rbp),%rcx
lea    -0x30(%rbp),%r8
mov    $0x0,%al
call   1030 <palDmat@plt>
cmpl   $0x0,-0x30(%rbp)
jne    1b98 <palFitxy+0xa78>
movsd  -0x130(%rbp),%xmm0
ff
movsd  %xmm0,-0x50(%rbp)
movsd  -0x128(%rbp),%xmm0
ff
movsd  %xmm0,-0x58(%rbp)
movsd  -0x120(%rbp),%xmm0
ff
movsd  %xmm0,-0x60(%rbp)
movsd  -0x118(%rbp),%xmm0
ff
movsd  %xmm0,-0x68(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1b93 <palFitxy+0xa73>
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movsd  %xmm0,-0x108(%rbp)
ff
mov    -0x18(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x110(%rbp)
ff
movsd  -0x50(%rbp),%xmm1
movsd  -0x58(%rbp),%xmm0
movsd  -0x108(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  -0x60(%rbp),%xmm1
movsd  -0x110(%rbp),%xmm2
ff
movq   %xmm1,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm1
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
movsd  (%rax),%xmm0
movsd  -0x210(%rbp),%xmm2
ff
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x238(%rbp)
ff
movsd  -0x68(%rbp),%xmm0
movsd  -0x60(%rbp),%xmm1
movsd  -0x108(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x58(%rbp),%xmm0
movsd  -0x110(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rbp),%rax
movslq -0x2c(%rbp),%rcx
shl    $0x4,%rcx
add    %rcx,%rax
subsd  0x8(%rax),%xmm0
movsd  %xmm0,-0x240(%rbp)
ff
movsd  -0x230(%rbp),%xmm0
ff
movsd  -0x238(%rbp),%xmm1
ff
movsd  -0x238(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0x240(%rbp),%xmm0
ff
movsd  -0x240(%rbp),%xmm2
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1a2f <palFitxy+0x90f>
jmp    1ba8 <palFitxy+0xa88>
movsd  0x460(%rip),%xmm0
movsd  %xmm0,-0x230(%rbp)
ff
cmpl   $0x0,-0x44(%rbp)
jne    1bf7 <palFitxy+0xad7>
cmpl   $0x0,-0x30(%rbp)
jne    1bf7 <palFitxy+0xad7>
movsd  -0x50(%rbp),%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x58(%rbp),%xmm0
movsd  %xmm0,-0x78(%rbp)
movsd  -0x60(%rbp),%xmm0
movsd  %xmm0,-0x80(%rbp)
movsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
movsd  -0x230(%rbp),%xmm0
ff
movsd  %xmm0,-0x90(%rbp)
ff
jmp    1bfc <palFitxy+0xadc>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    15f1 <palFitxy+0x4d1>
movsd  -0x90(%rbp),%xmm0
ff
xorps  %xmm1,%xmm1
ucomisd %xmm1,%xmm0
jb     1cb5 <palFitxy+0xb95>
movsd  -0x90(%rbp),%xmm1
ff
movsd  -0x230(%rbp),%xmm0
ff
ucomisd %xmm1,%xmm0
jae    1c43 <palFitxy+0xb23>
cmpl   $0x2,-0x8(%rbp)
jne    1cb5 <palFitxy+0xb95>
movsd  -0x70(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x78(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x80(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x88(%rbp),%xmm0
ff
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x80(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x78(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x28(%rax)
jmp    1d54 <palFitxy+0xc34>
cmpl   $0x0,-0x30(%rbp)
jne    1d45 <palFitxy+0xc25>
movsd  -0x50(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,(%rax)
movsd  -0x58(%rbp),%xmm0
movq   %xmm0,%rax
movabs $0x8000000000000000,%rcx
xor    %rcx,%rax
movq   %rax,%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x8(%rax)
movsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x10(%rax)
movsd  -0x68(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x18(%rax)
movsd  -0x60(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x20(%rax)
movsd  -0x58(%rbp),%xmm0
mov    -0x20(%rbp),%rax
movsd  %xmm0,0x28(%rax)
jmp    1d4f <palFitxy+0xc2f>
mov    -0x28(%rbp),%rax
movl   $0xfffffffd,(%rax)
jmp    1d54 <palFitxy+0xc34>
jmp    1d63 <palFitxy+0xc43>
mov    -0x28(%rbp),%rax
movl   $0xfffffffe,(%rax)
jmp    1d72 <palFitxy+0xc52>
mov    -0x28(%rbp),%rax
movl   $0xffffffff,(%rax)
jmp    1d77 <palFitxy+0xc57>
add    $0x240,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<palFitxy>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x158,%rsp
mov    %r9,%rbp
mov    %r8,%r15
mov    %rcx,%r12
mov    %rdx,%rbx
mov    %esi,%r14d
movl   $0x0,(%r9)
cvtsi2sd %esi,%xmm0
movsd  %xmm0,0x68(%rsp)
cmp    $0x4,%edi
je     12b4 <palFitxy+0x194>
cmp    $0x6,%edi
jne    1665 <palFitxy+0x545>
cmp    $0x3,%r14d
jl     166e <palFitxy+0x54e>
mov    %r14d,%eax
shl    $0x4,%rax
xorpd  %xmm5,%xmm5
xorpd  %xmm10,%xmm10
xor    %ecx,%ecx
xorpd  %xmm1,%xmm1
xorpd  %xmm11,%xmm11
xorpd  %xmm3,%xmm3
xorpd  %xmm0,%xmm0
movapd %xmm3,%xmm8
movapd %xmm1,%xmm9
movapd %xmm5,%xmm12
movupd (%rbx,%rcx,1),%xmm4
movupd (%r12,%rcx,1),%xmm2
movapd %xmm4,%xmm6
unpcklpd %xmm4,%xmm6
mulpd  %xmm2,%xmm6
movapd %xmm6,%xmm1
addpd  %xmm9,%xmm1
addpd  %xmm4,%xmm0
unpckhpd %xmm4,%xmm4
mulpd  %xmm2,%xmm4
movapd %xmm4,%xmm5
addpd  %xmm12,%xmm5
addpd  %xmm2,%xmm11
movapd %xmm2,%xmm7
unpcklpd %xmm2,%xmm7
mulpd  %xmm2,%xmm7
movapd %xmm7,%xmm3
addpd  %xmm8,%xmm3
unpckhpd %xmm2,%xmm2
mulsd  %xmm2,%xmm2
addsd  %xmm2,%xmm10
add    $0x10,%rcx
cmp    %rcx,%rax
jne    1190 <palFitxy+0x70>
movapd %xmm12,0x30(%rsp)
movapd %xmm4,0x40(%rsp)
addpd  %xmm8,%xmm7
addpd  %xmm9,%xmm6
movapd %xmm0,0x50(%rsp)
movlpd %xmm0,0x10(%rsp)
movupd %xmm6,0x18(%rsp)
movsd  0x68(%rsp),%xmm2
movsd  %xmm2,0xb0(%rsp)
movupd %xmm11,0xb8(%rsp)
movlpd %xmm11,0xc8(%rsp)
movapd %xmm7,0xd0(%rsp)
movhlps %xmm11,%xmm7
movaps %xmm7,0xe0(%rsp)
movsd  %xmm10,0xf0(%rsp)
lea    0xb0(%rsp),%rsi
lea    0x10(%rsp),%rdx
lea    0x98(%rsp),%rcx
lea    0xc(%rsp),%r8
lea    0x140(%rsp),%r9
mov    $0x3,%edi
xor    %eax,%eax
call   1030 <palDmat@plt>
cmpl   $0x0,0xc(%rsp)
je     1687 <palFitxy+0x567>
movl   $0xfffffffd,0x0(%rbp)
jmp    1675 <palFitxy+0x555>
cmp    $0x2,%r14d
jl     166e <palFitxy+0x54e>
mov    %rbp,0x88(%rsp)
mov    %r15,0x60(%rsp)
mov    %r14d,%r15d
shl    $0x4,%r15
xorpd  %xmm0,%xmm0
movapd %xmm0,0xa0(%rsp)
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x50(%rsp)
mov    $0x1,%r13b
movapd 0xd1b(%rip),%xmm11
lea    0x140(%rsp),%rbp
xorpd  %xmm0,%xmm0
movsd  %xmm0,0x40(%rsp)
xorpd  %xmm0,%xmm0
movapd %xmm0,0x30(%rsp)
xorpd  %xmm10,%xmm10
xorpd  %xmm0,%xmm0
movapd %xmm0,0x70(%rsp)
jmp    138f <palFitxy+0x26f>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  0xcd0(%rip),%xmm0
movapd 0x30(%rsp),%xmm8
movsd  0x40(%rsp),%xmm9
movsd  0x50(%rsp),%xmm3
movapd 0x70(%rsp),%xmm4
movapd 0x130(%rsp),%xmm10
movapd 0xcab(%rip),%xmm11
movsd  %xmm3,0x50(%rsp)
movsd  %xmm9,0x40(%rsp)
movapd %xmm8,0x30(%rsp)
movapd %xmm4,0x70(%rsp)
test   $0x1,%r13b
mov    $0x0,%r13d
je     1624 <palFitxy+0x504>
movsd  0xc68(%rip),%xmm12
test   $0x1,%r13b
jne    13a7 <palFitxy+0x287>
movsd  0xc61(%rip),%xmm12
movapd %xmm10,0x130(%rsp)
xorpd  %xmm4,%xmm4
xorpd  %xmm2,%xmm2
xor    %eax,%eax
xorpd  %xmm9,%xmm9
xorpd  %xmm3,%xmm3
xorpd  %xmm8,%xmm8
nopl   0x0(%rax)
movsd  (%rbx,%rax,1),%xmm5
mulsd  %xmm12,%xmm5
movsd  0x8(%rbx,%rax,1),%xmm6
movupd (%r12,%rax,1),%xmm7
movapd %xmm7,%xmm1
shufpd $0x1,%xmm7,%xmm1
addsd  %xmm5,%xmm3
unpcklpd %xmm5,%xmm5
movapd %xmm7,%xmm0
unpckhpd %xmm7,%xmm0
mulpd  %xmm7,%xmm5
addpd  %xmm4,%xmm5
movapd %xmm6,%xmm4
xorpd  %xmm11,%xmm4
addsd  %xmm6,%xmm9
unpcklpd %xmm4,%xmm6
mulpd  %xmm1,%xmm6
movapd %xmm6,%xmm4
addpd  %xmm5,%xmm4
addpd  %xmm1,%xmm8
mulsd  %xmm7,%xmm7
addsd  %xmm2,%xmm7
mulsd  %xmm0,%xmm0
movapd %xmm0,%xmm2
addsd  %xmm7,%xmm2
add    $0x10,%rax
cmp    %rax,%r15
jne    13d0 <palFitxy+0x2b0>
movsd  %xmm12,0x90(%rsp)
addpd  %xmm5,%xmm6
movsd  %xmm3,0x10(%rsp)
movupd %xmm6,0x18(%rsp)
movsd  %xmm9,0x28(%rsp)
movsd  0x68(%rsp),%xmm3
movsd  %xmm3,0xb0(%rsp)
movapd %xmm8,%xmm0
xorpd  %xmm11,%xmm0
movapd %xmm8,%xmm1
shufpd $0x1,%xmm0,%xmm1
movupd %xmm1,0xb8(%rsp)
movq   $0x0,0xc8(%rsp)
movhpd %xmm8,0xd0(%rsp)
movsd  %xmm2,0xd8(%rsp)
movq   $0x0,0xe0(%rsp)
movapd %xmm8,%xmm0
unpcklpd %xmm8,%xmm0
movupd %xmm0,0xe8(%rsp)
movq   $0x0,0xf8(%rsp)
shufpd $0x2,%xmm8,%xmm2
xorpd  %xmm11,%xmm2
movapd %xmm2,0x100(%rsp)
movq   $0x0,0x110(%rsp)
movupd %xmm8,0x118(%rsp)
movsd  %xmm3,0x128(%rsp)
mov    $0x4,%edi
lea    0xb0(%rsp),%rsi
lea    0x10(%rsp),%rdx
lea    0x98(%rsp),%rcx
lea    0xc(%rsp),%r8
mov    %rbp,%r9
xor    %eax,%eax
call   1030 <palDmat@plt>
mov    0xc(%rsp),%eax
test   %eax,%eax
jne    1330 <palFitxy+0x210>
movapd 0x10(%rsp),%xmm10
movapd 0x20(%rsp),%xmm1
movapd %xmm1,%xmm8
movapd %xmm1,%xmm12
movapd 0xaab(%rip),%xmm2
xorpd  %xmm2,%xmm12
movapd %xmm10,%xmm4
unpckhpd %xmm10,%xmm4
movapd %xmm1,%xmm9
unpckhpd %xmm1,%xmm9
xorpd  %xmm0,%xmm0
xor    %ecx,%ecx
movapd %xmm2,%xmm11
movsd  0x90(%rsp),%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r12,%rcx,1),%xmm5
movsd  0x8(%r12,%rcx,1),%xmm6
movapd %xmm4,%xmm7
mulsd  %xmm5,%xmm7
addsd  %xmm10,%xmm7
movapd %xmm12,%xmm3
mulsd  %xmm6,%xmm3
addsd  %xmm7,%xmm3
movsd  (%rbx,%rcx,1),%xmm7
mulsd  %xmm2,%xmm7
subsd  %xmm7,%xmm3
mulsd  %xmm1,%xmm5
addsd  %xmm9,%xmm5
mulsd  %xmm4,%xmm6
addsd  %xmm5,%xmm6
subsd  0x8(%rbx,%rcx,1),%xmm6
mulsd  %xmm3,%xmm3
addsd  %xmm0,%xmm3
mulsd  %xmm6,%xmm6
movapd %xmm6,%xmm0
addsd  %xmm3,%xmm0
add    $0x10,%rcx
cmp    %rcx,%r15
jne    15a0 <palFitxy+0x480>
movapd %xmm1,0xa0(%rsp)
movapd %xmm0,%xmm3
movapd %xmm10,%xmm4
test   $0x1,%r13b
jne    1365 <palFitxy+0x245>
xorpd  %xmm1,%xmm1
movsd  0x50(%rsp),%xmm2
ucomisd %xmm1,%xmm2
jb     1648 <palFitxy+0x528>
cmp    $0x2,%r14d
je     16d4 <palFitxy+0x5b4>
ucomisd %xmm2,%xmm0
jae    16d4 <palFitxy+0x5b4>
test   %eax,%eax
mov    0x60(%rsp),%rax
je     1714 <palFitxy+0x5f4>
mov    0x88(%rsp),%rax
movl   $0xfffffffd,(%rax)
jmp    1675 <palFitxy+0x555>
movl   $0xffffffff,0x0(%rbp)
jmp    1675 <palFitxy+0x555>
movl   $0xfffffffe,0x0(%rbp)
add    $0x158,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movapd 0x40(%rsp),%xmm1
addpd  0x30(%rsp),%xmm1
mov    0x20(%rsp),%rax
mov    %rax,0x10(%r15)
movaps 0x10(%rsp),%xmm0
movups %xmm0,(%r15)
movapd 0x50(%rsp),%xmm0
movhpd %xmm0,0x10(%rsp)
movupd %xmm1,0x18(%rsp)
add    $0x18,%r15
lea    0xb0(%rsp),%rdi
lea    0x10(%rsp),%rsi
mov    %r15,%rdx
xor    %eax,%eax
call   1040 <palDmxv@plt>
jmp    1675 <palFitxy+0x555>
mov    0x60(%rsp),%rax
movapd 0x70(%rsp),%xmm2
movupd %xmm2,(%rax)
movapd 0x925(%rip),%xmm0
movapd 0x30(%rsp),%xmm1
xorpd  %xmm1,%xmm0
movlpd %xmm0,0x10(%rax)
movsd  0x40(%rsp),%xmm0
movsd  %xmm0,0x18(%rax)
movsd  %xmm1,0x20(%rax)
movhpd %xmm2,0x28(%rax)
jmp    1675 <palFitxy+0x555>
movapd 0x8f4(%rip),%xmm0
xorpd  %xmm10,%xmm0
movupd %xmm0,(%rax)
movapd 0xa0(%rsp),%xmm0
movupd %xmm0,0x10(%rax)
movsd  %xmm0,%xmm10
movupd %xmm10,0x20(%rax)
jmp    1675 <palFitxy+0x555>

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

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