#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ BasisFuns(int, double, int, double *, double *, double *,
                             double *);
int FindSpan(int, int, double, double *);
void computeLinGNmatPnt2Pnt(int degU, int degV, double *cp, int ncp, int kcp,
                            double *knotU, double *knotV, double *us, int nus,
                            double *dirOffset, double *cpDir,
                            double *sgnDistDiff, double *HessApprx,
                            double *gradIent, int *derivInds, double *derivVals,
                            double *leftU, double *rightU, double *NU,
                            double *leftV, double *rightV, double *NV) {
  int i, j, ii, twoii, threeii, spanU, spanV, ind, ind2, dind, fourncp, myint,
      numCP, orderU, orderV, nnz, cpInd;
  double bspnt[4], doubleVals[3];
  fourncp = 4 * ncp;
  orderU = degU + 1;
  orderV = degV + 1;
  nnz = orderU * orderV;
  numCP = ncp * kcp;
  for (ii = 0; ii < nus; ii++) {
    twoii = 2 * ii;
    threeii = 3 * ii;
    spanU = FindSpan(ncp, degU, us[twoii], knotU);
    BasisFuns(spanU, us[twoii], degU, knotU, NU, leftU, rightU);
    ind = spanU - degU;
    spanV = FindSpan(kcp, degV, us[twoii + 1], knotV);
    BasisFuns(spanV, us[twoii + 1], degV, knotV, NV, leftV, rightV);
    ind2 = spanV - degV;
    myint = ind2 * fourncp + ind * 4;
    bspnt[0] = 0.0;
    bspnt[1] = 0.0;
    bspnt[2] = 0.0;
    bspnt[3] = 0.0;
    for (i = 0; i <= degV; i++) {
      for (j = 0; j <= degU; j++) {
        bspnt[0] += NV[i] * NU[j] * cp[i * fourncp + j * 4 + myint];
        bspnt[1] += NV[i] * NU[j] * cp[i * fourncp + j * 4 + myint + 1];
        bspnt[2] += NV[i] * NU[j] * cp[i * fourncp + j * 4 + myint + 2];
        bspnt[3] += NV[i] * NU[j] * cp[i * fourncp + j * 4 + myint + 3];
      }
    }
    dind = 0;
    for (i = 0; i <= degV; i++) {
      for (j = 0; j <= degU; j++) {
        cpInd = (ind2 + i) * ncp + ind + j;
        derivInds[dind] = cpInd;
        cpInd = 3 * cpInd;
        doubleVals[0] = NV[i] * NU[j] / bspnt[3];
        derivVals[3 * dind] = doubleVals[0] * cpDir[cpInd];
        derivVals[3 * dind + 1] = doubleVals[0] * cpDir[cpInd + 1];
        derivVals[3 * dind + 2] = doubleVals[0] * cpDir[cpInd + 2];
        dind++;
      }
    }
    doubleVals[0] = sgnDistDiff[ii] * dirOffset[threeii];
    doubleVals[1] = sgnDistDiff[ii] * dirOffset[threeii + 1];
    doubleVals[2] = sgnDistDiff[ii] * dirOffset[threeii + 2];
    for (i = 0; i < nnz; i++) {
      gradIent[derivInds[i]] += doubleVals[0] * derivVals[3 * i] +
                                doubleVals[1] * derivVals[3 * i + 1] +
                                doubleVals[2] * derivVals[3 * i + 2];
      for (j = 0; j < nnz; j++) {
        if (derivInds[j] >= derivInds[i]) {
          HessApprx[derivInds[i] * numCP + derivInds[j]] +=
              derivVals[3 * i] * derivVals[3 * j] +
              derivVals[3 * i + 1] * derivVals[3 * j + 1] +
              derivVals[3 * i + 2] * derivVals[3 * j + 2];
        }
      }
    }
  }
  for (i = 1; i < numCP; i++) {
    for (j = 0; j < i; j++) {
      HessApprx[i * numCP + j] = HessApprx[j * numCP + i];
    }
  }
  return;
}


x86 assembly (clang, -O0):
<computeLinGNmatPnt2Pnt>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x88(%rbp),%rax
mov    0x80(%rbp),%rax
mov    0x78(%rbp),%rax
mov    0x70(%rbp),%rax
mov    0x68(%rbp),%rax
mov    0x60(%rbp),%rax
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%rax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%eax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %rdx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9,-0x20(%rbp)
mov    -0x14(%rbp),%eax
shl    $0x2,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x58(%rbp),%eax
imul   -0x5c(%rbp),%eax
mov    %eax,-0x60(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x18(%rbp),%eax
mov    %eax,-0x54(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    0x20(%rbp),%eax
jge    1781 <computeLinGNmatPnt2Pnt+0x661>
mov    -0x2c(%rbp),%eax
shl    $0x1,%eax
mov    %eax,-0x30(%rbp)
imul   $0x3,-0x2c(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x14(%rbp),%edi
mov    -0x4(%rbp),%esi
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x20(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%edi
mov    0x18(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x4(%rbp),%esi
mov    -0x20(%rbp),%rdx
mov    0x70(%rbp),%rcx
mov    0x60(%rbp),%r8
mov    0x68(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x38(%rbp),%eax
sub    -0x4(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x18(%rbp),%edi
mov    -0x8(%rbp),%esi
mov    0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x10(%rbp),%rdx
call   1040 <FindSpan@plt>
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%edi
mov    0x18(%rbp),%rax
mov    -0x30(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x8(%rbp),%esi
mov    0x10(%rbp),%rdx
mov    0x88(%rbp),%rcx
mov    0x78(%rbp),%r8
mov    0x80(%rbp),%r9
call   1030 <BasisFuns@plt>
mov    -0x3c(%rbp),%eax
sub    -0x8(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
imul   -0x4c(%rbp),%eax
mov    -0x40(%rbp),%ecx
shl    $0x2,%ecx
add    %ecx,%eax
mov    %eax,-0x50(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x80(%rbp)
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     144f <computeLinGNmatPnt2Pnt+0x32f>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     143c <computeLinGNmatPnt2Pnt+0x31c>
mov    0x88(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x4c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x50(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x90(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x90(%rbp)
ff
mov    0x88(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x4c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x88(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x88(%rbp)
ff
mov    0x88(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x4c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x50(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x80(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
mov    0x88(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x4c(%rbp),%ecx
mov    -0x28(%rbp),%edx
shl    $0x2,%edx
add    %edx,%ecx
add    -0x50(%rbp),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0x78(%rbp),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12d9 <computeLinGNmatPnt2Pnt+0x1b9>
jmp    1441 <computeLinGNmatPnt2Pnt+0x321>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12c6 <computeLinGNmatPnt2Pnt+0x1a6>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1577 <computeLinGNmatPnt2Pnt+0x457>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1564 <computeLinGNmatPnt2Pnt+0x444>
mov    -0x44(%rbp),%eax
add    -0x24(%rbp),%eax
imul   -0x14(%rbp),%eax
add    -0x40(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    -0x64(%rbp),%edx
mov    0x50(%rbp),%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
imul   $0x3,-0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
mov    0x88(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
divsd  -0x78(%rbp),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
imul   $0x3,-0x48(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x30(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
imul   $0x3,-0x48(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0xb0(%rbp),%xmm0
ff
mov    0x30(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
imul   $0x3,-0x48(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1470 <computeLinGNmatPnt2Pnt+0x350>
jmp    1569 <computeLinGNmatPnt2Pnt+0x449>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    145d <computeLinGNmatPnt2Pnt+0x33d>
mov    0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xb0(%rbp)
ff
mov    0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa8(%rbp)
ff
mov    0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0xa0(%rbp)
ff
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    176e <computeLinGNmatPnt2Pnt+0x64e>
movsd  -0xb0(%rbp),%xmm1
ff
mov    0x58(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xa8(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
movsd  -0xa0(%rbp),%xmm0
ff
mov    0x58(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x48(%rbp),%rax
mov    0x50(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    175b <computeLinGNmatPnt2Pnt+0x63b>
mov    0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    0x50(%rbp),%rcx
movslq -0x24(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jl     1748 <computeLinGNmatPnt2Pnt+0x628>
mov    0x58(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x58(%rbp),%rax
imul   $0x3,-0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x58(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
imul   $0x3,-0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    0x58(%rbp),%rax
imul   $0x3,-0x24(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
imul   $0x3,-0x28(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x40(%rbp),%rax
mov    0x50(%rbp),%rcx
movslq -0x24(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
imul   -0x54(%rbp),%ecx
mov    0x50(%rbp),%rdx
movslq -0x28(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    174d <computeLinGNmatPnt2Pnt+0x62d>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1679 <computeLinGNmatPnt2Pnt+0x559>
jmp    1760 <computeLinGNmatPnt2Pnt+0x640>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    15ee <computeLinGNmatPnt2Pnt+0x4ce>
jmp    1773 <computeLinGNmatPnt2Pnt+0x653>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11bb <computeLinGNmatPnt2Pnt+0x9b>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    17f4 <computeLinGNmatPnt2Pnt+0x6d4>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    17e1 <computeLinGNmatPnt2Pnt+0x6c1>
mov    0x40(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x54(%rbp),%ecx
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    179b <computeLinGNmatPnt2Pnt+0x67b>
jmp    17e6 <computeLinGNmatPnt2Pnt+0x6c6>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1788 <computeLinGNmatPnt2Pnt+0x668>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<computeLinGNmatPnt2Pnt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %r9,0x80(%rsp)
mov    %rdx,%r12
mov    %rsi,0x30(%rsp)
mov    %rdi,0x8(%rsp)
mov    0x100(%rsp),%eax
mov    %r8d,0x50(%rsp)
mov    %r8d,%r11d
mov    %rcx,%rdx
mov    %rcx,0x20(%rsp)
imul   %ecx,%r11d
test   %eax,%eax
jle    1881 <computeLinGNmatPnt2Pnt+0x761>
mov    0x138(%rsp),%r13
mov    0x8(%rsp),%rdx
lea    0x1(%rdx),%esi
mov    0x30(%rsp),%rcx
lea    0x1(%rcx),%edi
mov    %eax,%eax
mov    %rax,0x78(%rsp)
mov    %edi,%eax
mov    %rax,0x60(%rsp)
imul   %esi,%edi
mov    %esi,0x54(%rsp)
mov    %esi,%esi
lea    0x0(,%rsi,8),%rax
lea    (%rax,%rax,2),%rax
lea    (%rax,%r13,1),%rbp
mov    %rbp,0x98(%rsp)
add    0x110(%rsp),%rax
mov    %rax,0xa0(%rsp)
mov    %esi,%eax
and    $0xfffffffe,%eax
mov    %rax,0x88(%rsp)
lea    0x0(,%rdx,4),%eax
neg    %eax
mov    %eax,0x44(%rsp)
neg    %ecx
mov    %rcx,0x70(%rsp)
lea    0x0(,%rsi,4),%rax
and    $0xfffffffffffffff8,%rax
mov    %rax,0x68(%rsp)
mov    %edx,%eax
neg    %eax
mov    %eax,0x40(%rsp)
mov    0x150(%rsp),%r15
mov    0x20(%rsp),%rax
lea    0x0(,%rax,4),%eax
mov    %edi,0x48(%rsp)
mov    %edi,%ecx
mov    %rsi,0x38(%rsp)
lea    (%r15,%rsi,8),%rdx
mov    %rdx,0x90(%rsp)
mov    %eax,0x2c(%rsp)
mov    %eax,%eax
mov    %rax,0xa8(%rsp)
mov    %rcx,0xb0(%rsp)
lea    (%rcx,%rcx,2),%r14
xor    %ebx,%ebx
mov    %r11d,0x4c(%rsp)
jmp    1264 <computeLinGNmatPnt2Pnt+0x144>
nopl   0x0(%rax,%rax,1)
mov    0x58(%rsp),%rbx
add    $0x1,%rbx
cmp    0x78(%rsp),%rbx
je     1881 <computeLinGNmatPnt2Pnt+0x761>
mov    %rbx,0x58(%rsp)
shl    $0x4,%rbx
mov    0xf8(%rsp),%rax
movsd  (%rax,%rbx,1),%xmm0
mov    0x20(%rsp),%rdi
mov    0x8(%rsp),%rsi
mov    0x80(%rsp),%rbp
mov    %rbp,%rdx
call   1040 <FindSpan@plt>
mov    0xf8(%rsp),%rcx
movsd  (%rcx,%rbx,1),%xmm0
mov    %rax,0x18(%rsp)
mov    %eax,%edi
mov    0x8(%rsp),%rsi
mov    %rbp,%rdx
mov    %r15,%rcx
mov    0x140(%rsp),%r8
mov    0x148(%rsp),%r9
call   1030 <BasisFuns@plt>
mov    0xf8(%rsp),%rax
movsd  0x8(%rax,%rbx,1),%xmm0
mov    0x50(%rsp),%edi
mov    0x30(%rsp),%rbp
mov    %ebp,%esi
mov    0xf0(%rsp),%rdx
call   1040 <FindSpan@plt>
mov    0xf8(%rsp),%rcx
movsd  0x8(%rcx,%rbx,1),%xmm0
mov    %eax,%edi
mov    %rax,%rbx
mov    %ebp,%esi
mov    0xf0(%rsp),%rdx
mov    0x168(%rsp),%rcx
mov    0x158(%rsp),%r8
mov    0x160(%rsp),%r9
call   1030 <BasisFuns@plt>
mov    0x8(%rsp),%rcx
mov    0x168(%rsp),%r10
test   %ebp,%ebp
mov    0x60(%rsp),%rbp
js     1750 <computeLinGNmatPnt2Pnt+0x630>
mov    %rbx,%r9
mov    0x18(%rsp),%rdi
mov    %edi,%eax
sub    %ecx,%eax
mov    %eax,0x4(%rsp)
mov    0x70(%rsp),%rax
lea    (%rax,%rbx,1),%r11d
sub    0x30(%rsp),%r9d
mov    0x2c(%rsp),%eax
imul   %r11d,%eax
add    0x44(%rsp),%eax
lea    (%rax,%rdi,4),%edx
xorpd  %xmm0,%xmm0
xor    %esi,%esi
mov    0x68(%rsp),%rbx
mov    %rdi,%rax
mov    %rdi,%r8
jmp    13a5 <computeLinGNmatPnt2Pnt+0x285>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
add    $0x1,%rsi
add    0xa8(%rsp),%rdx
cmp    %rbp,%rsi
je     1460 <computeLinGNmatPnt2Pnt+0x340>
test   %ecx,%ecx
js     1390 <computeLinGNmatPnt2Pnt+0x270>
movsd  (%r10,%rsi,8),%xmm1
je     1410 <computeLinGNmatPnt2Pnt+0x2f0>
xor    %eax,%eax
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r15,%rax,2),%xmm2
mulsd  %xmm1,%xmm2
lea    (%rdx,%rax,1),%ecx
add    $0x3,%ecx
movslq %ecx,%rcx
mulsd  (%r12,%rcx,8),%xmm2
addsd  %xmm0,%xmm2
movsd  0x8(%r15,%rax,2),%xmm0
mulsd  %xmm1,%xmm0
lea    0x7(%rdx,%rax,1),%ecx
movslq %ecx,%rcx
mulsd  (%r12,%rcx,8),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rdi
add    $0x8,%rax
cmp    %rax,%rbx
jne    13c0 <computeLinGNmatPnt2Pnt+0x2a0>
jmp    1412 <computeLinGNmatPnt2Pnt+0x2f2>
nopl   0x0(%rax,%rax,1)
xor    %edi,%edi
testb  $0x1,0x38(%rsp)
mov    0x8(%rsp),%rcx
mov    %r8,%rax
je     1390 <computeLinGNmatPnt2Pnt+0x270>
lea    (%r9,%rsi,1),%eax
mulsd  (%r15,%rdi,8),%xmm1
imul   0x2c(%rsp),%eax
add    0x4(%rsp),%edi
lea    (%rax,%rdi,4),%eax
or     $0x3,%eax
cltq
mulsd  (%r12,%rax,8),%xmm1
mov    %r8,%rax
addsd  %xmm1,%xmm0
jmp    1390 <computeLinGNmatPnt2Pnt+0x270>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %r9,%rdi
cmpl   $0x0,0x30(%rsp)
js     1750 <computeLinGNmatPnt2Pnt+0x630>
mov    %rax,%rdx
mov    0x20(%rsp),%rax
imul   %eax,%edi
add    %edi,0x4(%rsp)
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
add    0x40(%rsp),%edx
imul   %eax,%r11d
add    %edx,%r11d
xor    %r9d,%r9d
xor    %edx,%edx
jmp    14bc <computeLinGNmatPnt2Pnt+0x39c>
nopw   0x0(%rax,%rax,1)
mov    0x8(%rsp),%rcx
mov    0x60(%rsp),%rbp
add    $0x1,%r9
add    0x20(%rsp),%r11d
cmp    %rbp,%r9
je     1750 <computeLinGNmatPnt2Pnt+0x630>
test   %ecx,%ecx
js     14aa <computeLinGNmatPnt2Pnt+0x38a>
movslq %r11d,%rdi
movslq %edx,%rcx
cmpl   $0x2,0x54(%rsp)
jae    14e0 <computeLinGNmatPnt2Pnt+0x3c0>
mov    %rcx,%rdx
xor    %eax,%eax
jmp    168a <computeLinGNmatPnt2Pnt+0x56a>
nopw   0x0(%rax,%rax,1)
mov    %rdi,0x10(%rsp)
mov    %r9d,%eax
imul   0x20(%rsp),%eax
add    0x4(%rsp),%eax
cltq
shl    $0x3,%rax
lea    (%rax,%rax,2),%rdi
mov    0x110(%rsp),%rax
lea    (%rax,%rdi,1),%r8
add    0xa0(%rsp),%rdi
lea    (%r10,%r9,8),%rax
lea    (%r10,%r9,8),%rsi
add    $0x8,%rsi
lea    0x0(,%rcx,8),%rbx
lea    (%rbx,%rbx,2),%rbp
mov    %r13,%rbx
add    %rbp,%rbx
add    0x98(%rsp),%rbp
cmp    %rsi,%rbx
setb   %r10b
cmp    %rbp,%rax
setb   %dl
cmp    0x90(%rsp),%rbx
setb   %al
cmp    %r15,%rbp
seta   %sil
cmp    %rdi,%rbx
setb   %bl
cmp    %rbp,%r8
setb   %dil
test   %dl,%r10b
jne    1680 <computeLinGNmatPnt2Pnt+0x560>
and    %sil,%al
jne    1680 <computeLinGNmatPnt2Pnt+0x560>
and    %dil,%bl
mov    0x168(%rsp),%r10
jne    1680 <computeLinGNmatPnt2Pnt+0x560>
mov    0x10(%rsp),%rax
lea    (%rax,%rax,2),%rax
mov    0x110(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
mov    0x88(%rsp),%rbp
lea    0x0(%rbp,%rcx,1),%rdx
mov    %rdx,0x18(%rsp)
mov    0x130(%rsp),%rdx
lea    (%rdx,%rcx,4),%rdi
lea    (%rcx,%rcx,2),%rcx
lea    0x0(,%rcx,8),%rsi
add    %r13,%rsi
xor    %ecx,%ecx
xor    %r8d,%r8d
nopl   0x0(%rax,%rax,1)
lea    (%r11,%r8,1),%edx
lea    (%r11,%r8,1),%ebx
add    $0x1,%ebx
movd   %ebx,%xmm2
movd   %edx,%xmm3
punpckldq %xmm2,%xmm3
movq   %xmm3,(%rdi,%r8,4)
movsd  (%r10,%r9,8),%xmm2
unpcklpd %xmm2,%xmm2
movupd (%r15,%r8,8),%xmm3
mulpd  %xmm2,%xmm3
divpd  %xmm1,%xmm3
movupd (%rax,%rcx,2),%xmm2
movupd 0x10(%rax,%rcx,2),%xmm4
movupd 0x20(%rax,%rcx,2),%xmm5
movapd %xmm4,%xmm6
movsd  %xmm2,%xmm6
shufpd $0x1,%xmm5,%xmm2
movsd  %xmm4,%xmm5
mulpd  %xmm3,%xmm6
mulpd  %xmm3,%xmm2
mulpd  %xmm3,%xmm5
movapd %xmm6,%xmm3
unpcklpd %xmm2,%xmm3
unpckhpd %xmm5,%xmm2
shufpd $0x2,%xmm6,%xmm5
movupd %xmm5,0x10(%rsi,%rcx,2)
movupd %xmm2,0x20(%rsi,%rcx,2)
movupd %xmm3,(%rsi,%rcx,2)
add    $0x2,%r8
add    $0x18,%rcx
cmp    %r8,%rbp
jne    15d0 <computeLinGNmatPnt2Pnt+0x4b0>
mov    %rbp,%rax
cmp    0x38(%rsp),%rbp
mov    0x18(%rsp),%rdx
mov    0x10(%rsp),%rdi
je     14a0 <computeLinGNmatPnt2Pnt+0x380>
jmp    168a <computeLinGNmatPnt2Pnt+0x56a>
mov    %rcx,%rdx
xor    %eax,%eax
mov    0x10(%rsp),%rdi
mov    0x130(%rsp),%rcx
lea    (%rcx,%rdx,4),%r8
mov    %rdx,0x18(%rsp)
lea    (%rdx,%rdx,2),%rcx
lea    0x0(,%rcx,8),%rcx
add    %r13,%rcx
lea    (%rax,%rdi,1),%esi
add    %rax,%rdi
lea    (%rdi,%rdi,2),%rdx
mov    0x110(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdi
lea    (%r15,%rax,8),%rbx
mov    0x38(%rsp),%rdx
sub    %rax,%rdx
mov    $0x2,%ebp
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
lea    (%rsi,%rax,1),%r10d
mov    %r10d,(%r8,%rax,4)
mov    0x168(%rsp),%r10
movsd  (%r10,%r9,8),%xmm2
mulsd  (%rbx,%rax,8),%xmm2
divsd  %xmm0,%xmm2
movsd  -0x10(%rdi,%rbp,8),%xmm3
mulsd  %xmm2,%xmm3
movsd  %xmm3,-0x10(%rcx,%rbp,8)
movsd  -0x8(%rdi,%rbp,8),%xmm3
mulsd  %xmm2,%xmm3
movsd  %xmm3,-0x8(%rcx,%rbp,8)
mulsd  (%rdi,%rbp,8),%xmm2
movsd  %xmm2,(%rcx,%rbp,8)
add    $0x1,%rax
add    $0x3,%rbp
cmp    %rax,%rdx
jne    16e0 <computeLinGNmatPnt2Pnt+0x5c0>
mov    0x18(%rsp),%rdx
add    %rax,%rdx
jmp    14a0 <computeLinGNmatPnt2Pnt+0x380>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmpl   $0x0,0x48(%rsp)
mov    0x120(%rsp),%r10
mov    0x4c(%rsp),%r11d
jle    1250 <computeLinGNmatPnt2Pnt+0x130>
mov    0x58(%rsp),%rdx
lea    (%rdx,%rdx,2),%eax
mov    0x118(%rsp),%rcx
movsd  (%rcx,%rdx,8),%xmm0
mov    %eax,%eax
mov    0x108(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm1
mulsd  %xmm0,%xmm1
movsd  0x8(%rcx,%rax,8),%xmm2
mulsd  %xmm0,%xmm2
mulsd  0x10(%rcx,%rax,8),%xmm0
xor    %r8d,%r8d
jmp    17c2 <computeLinGNmatPnt2Pnt+0x6a2>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0x1,%r8
cmp    0xb0(%rsp),%r8
je     1250 <computeLinGNmatPnt2Pnt+0x130>
lea    (%r8,%r8,2),%rcx
movsd  0x8(%r13,%rcx,8),%xmm3
mulsd  %xmm2,%xmm3
movsd  0x0(%r13,%rcx,8),%xmm4
mulsd  %xmm1,%xmm4
addsd  %xmm3,%xmm4
movsd  0x10(%r13,%rcx,8),%xmm3
mulsd  %xmm0,%xmm3
addsd  %xmm4,%xmm3
mov    0x130(%rsp),%rdi
movslq (%rdi,%r8,4),%rdx
mov    0x128(%rsp),%rax
addsd  (%rax,%rdx,8),%xmm3
movsd  %xmm3,(%rax,%rdx,8)
mov    %edx,%r9d
imul   %r11d,%r9d
xor    %ebx,%ebx
jmp    182d <computeLinGNmatPnt2Pnt+0x70d>
nopl   0x0(%rax,%rax,1)
add    $0x3,%rbx
add    $0x4,%rdi
cmp    %rbx,%r14
je     17b0 <computeLinGNmatPnt2Pnt+0x690>
mov    (%rdi),%ebp
cmp    %edx,%ebp
jl     1820 <computeLinGNmatPnt2Pnt+0x700>
mov    %ebx,%eax
movsd  0x0(%r13,%rcx,8),%xmm3
movsd  0x8(%r13,%rcx,8),%xmm4
lea    0x1(%rbx),%esi
mulsd  0x0(%r13,%rsi,8),%xmm4
mulsd  0x0(%r13,%rax,8),%xmm3
addsd  %xmm4,%xmm3
movsd  0x10(%r13,%rcx,8),%xmm4
lea    0x2(%rbx),%eax
mulsd  0x0(%r13,%rax,8),%xmm4
addsd  %xmm3,%xmm4
add    %r9d,%ebp
movslq %ebp,%rax
addsd  (%r10,%rax,8),%xmm4
movsd  %xmm4,(%r10,%rax,8)
jmp    1820 <computeLinGNmatPnt2Pnt+0x700>
cmp    $0x2,%r11d
jl     1955 <computeLinGNmatPnt2Pnt+0x835>
mov    %r11d,%r9d
mov    0x120(%rsp),%rax
lea    (%rax,%r9,8),%rcx
add    $0x8,%rcx
mov    %r9,%r14
shl    $0x4,%r14
lea    0x0(,%r9,8),%r8
lea    0x8(%rax),%rdi
mov    $0x1,%r11d
xor    %r10d,%r10d
mov    %rcx,%rsi
jmp    18d8 <computeLinGNmatPnt2Pnt+0x7b8>
nop
add    $0x1,%r11
add    $0x1,%r10
add    $0x8,%rsi
add    %r8,%rcx
add    $0x8,%rdi
cmp    %r9,%r11
je     1955 <computeLinGNmatPnt2Pnt+0x835>
test   %r10,%r10
je     1920 <computeLinGNmatPnt2Pnt+0x800>
mov    %r11,%rbp
and    $0xfffffffffffffffe,%rbp
xor    %ebx,%ebx
xor    %edx,%edx
nopl   0x0(%rax,%rax,1)
movsd  (%rdi,%rbx,1),%xmm0
movsd  %xmm0,-0x8(%rcx,%rdx,8)
movsd  (%rsi,%rbx,1),%xmm0
movsd  %xmm0,(%rcx,%rdx,8)
add    $0x2,%rdx
add    %r14,%rbx
cmp    %rdx,%rbp
jne    18f0 <computeLinGNmatPnt2Pnt+0x7d0>
test   $0x1,%r11b
je     18c0 <computeLinGNmatPnt2Pnt+0x7a0>
jmp    1928 <computeLinGNmatPnt2Pnt+0x808>
nopl   0x0(%rax)
xor    %edx,%edx
test   $0x1,%r11b
je     18c0 <computeLinGNmatPnt2Pnt+0x7a0>
mov    %r11,%rbx
imul   %r9,%rbx
mov    %rdx,%rax
imul   %r9,%rax
add    %r11,%rax
mov    0x120(%rsp),%rbp
movsd  0x0(%rbp,%rax,8),%xmm0
add    %rdx,%rbx
movsd  %xmm0,0x0(%rbp,%rbx,8)
jmp    18c0 <computeLinGNmatPnt2Pnt+0x7a0>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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