#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 computeLinGNmatPnt2Pln(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];
  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;
        derivVals[dind] = NV[i] * NU[j] *
                          (dirOffset[threeii] * cpDir[cpInd] +
                           dirOffset[threeii + 1] * cpDir[cpInd + 1] +
                           dirOffset[threeii + 2] * cpDir[cpInd + 2]) /
                          bspnt[3];
        dind++;
      }
    }
    for (i = 0; i < nnz; i++) {
      gradIent[derivInds[i]] += sgnDistDiff[ii] * derivVals[i];
      for (j = 0; j < nnz; j++) {
        if (derivInds[j] >= derivInds[i]) {
          HessApprx[derivInds[i] * numCP + derivInds[j]] +=
              derivVals[i] * derivVals[j];
        }
      }
    }
  }
  for (i = 1; i < numCP; i++) {
    for (j = 0; j < i; j++) {
      HessApprx[i * numCP + j] = HessApprx[j * numCP + i];
    }
  }
}


x86 assembly (clang, -O0):
<computeLinGNmatPnt2Pln>:
push   %rbp
mov    %rsp,%rbp
sub    $0x90,%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    1677 <computeLinGNmatPnt2Pln+0x557>
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 <computeLinGNmatPnt2Pln+0x32f>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     143c <computeLinGNmatPnt2Pln+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 <computeLinGNmatPnt2Pln+0x1b9>
jmp    1441 <computeLinGNmatPnt2Pln+0x321>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12c6 <computeLinGNmatPnt2Pln+0x1a6>
movl   $0x0,-0x48(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x8(%rbp),%eax
jg     1573 <computeLinGNmatPnt2Pln+0x453>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x4(%rbp),%eax
jg     1560 <computeLinGNmatPnt2Pln+0x440>
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
mov    0x28(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x30(%rbp),%rax
movslq -0x64(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm3
mov    0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x30(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
mov    0x28(%rbp),%rax
mov    -0x34(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x30(%rbp),%rax
mov    -0x64(%rbp),%ecx
add    $0x2,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm3
mulsd  %xmm3,%xmm1
addsd  %xmm2,%xmm1
mulsd  %xmm1,%xmm0
divsd  -0x78(%rbp),%xmm0
mov    0x58(%rbp),%rax
movslq -0x48(%rbp),%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 <computeLinGNmatPnt2Pln+0x350>
jmp    1565 <computeLinGNmatPnt2Pln+0x445>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    145d <computeLinGNmatPnt2Pln+0x33d>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    1664 <computeLinGNmatPnt2Pln+0x544>
mov    0x38(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x48(%rbp),%rax
mov    0x50(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movslq (%rcx,%rdx,4),%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x60(%rbp),%eax
jge    1651 <computeLinGNmatPnt2Pln+0x531>
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     163e <computeLinGNmatPnt2Pln+0x51e>
mov    0x58(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x58(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
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
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1643 <computeLinGNmatPnt2Pln+0x523>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    15c9 <computeLinGNmatPnt2Pln+0x4a9>
jmp    1656 <computeLinGNmatPnt2Pln+0x536>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    157a <computeLinGNmatPnt2Pln+0x45a>
jmp    1669 <computeLinGNmatPnt2Pln+0x549>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    11bb <computeLinGNmatPnt2Pln+0x9b>
movl   $0x1,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x54(%rbp),%eax
jge    16ea <computeLinGNmatPnt2Pln+0x5ca>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jge    16d7 <computeLinGNmatPnt2Pln+0x5b7>
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    1691 <computeLinGNmatPnt2Pln+0x571>
jmp    16dc <computeLinGNmatPnt2Pln+0x5bc>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    167e <computeLinGNmatPnt2Pln+0x55e>
add    $0x90,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<computeLinGNmatPnt2Pln>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %r9,0xa0(%rsp)
mov    %rsi,0x20(%rsp)
mov    0x160(%rsp),%eax
mov    %r8d,0x70(%rsp)
imul   %ecx,%r8d
test   %eax,%eax
jle    1965 <computeLinGNmatPnt2Pln+0x845>
mov    %ecx,%r11d
mov    %rdx,%r13
mov    %edi,%r14d
mov    0x170(%rsp),%rdx
lea    0x1(%r14),%esi
mov    0x20(%rsp),%rcx
lea    0x1(%rcx),%edi
mov    %eax,%eax
mov    %rax,0x98(%rsp)
mov    %edi,%r15d
imul   %esi,%edi
mov    %esi,0x74(%rsp)
mov    %esi,%r9d
lea    (%r9,%r9,2),%rax
lea    (%rdx,%rax,8),%rax
mov    %rax,0xc0(%rsp)
mov    %r9d,%eax
and    $0xfffffffe,%eax
mov    %rax,0xa8(%rsp)
lea    0x0(,%r14,4),%eax
neg    %eax
mov    %eax,0x64(%rsp)
mov    %ecx,%eax
neg    %eax
mov    %eax,0x60(%rsp)
lea    0x0(,%r9,4),%r10
and    $0xfffffffffffffff8,%r10
mov    %r14d,%eax
neg    %eax
mov    %eax,0x5c(%rsp)
mov    0x1b0(%rsp),%rax
mov    0x198(%rsp),%rbx
mov    0x168(%rsp),%rcx
lea    0x0(,%r11,4),%esi
mov    %edi,0x68(%rsp)
mov    %edi,%r12d
lea    (%rbx,%r9,8),%rdi
mov    %rdi,0xb8(%rsp)
lea    (%rax,%r9,8),%rax
mov    %rax,0xb0(%rsp)
lea    0x8(%rcx),%rax
mov    %rax,0x88(%rsp)
mov    %esi,0x2c(%rsp)
mov    %esi,%eax
mov    %rax,0x110(%rsp)
lea    0x10(%rdx),%rax
mov    %rax,0x100(%rsp)
xor    %ebp,%ebp
mov    %r15,0x108(%rsp)
mov    %r11,0x78(%rsp)
mov    %r14,0x40(%rsp)
mov    %r8d,0x6c(%rsp)
mov    %r9,0x48(%rsp)
mov    %r10,0x90(%rsp)
mov    %r13,0xf8(%rsp)
jmp    1287 <computeLinGNmatPnt2Pln+0x167>
nopl   0x0(%rax,%rax,1)
mov    0x50(%rsp),%rbp
add    $0x1,%rbp
cmp    0x98(%rsp),%rbp
je     1965 <computeLinGNmatPnt2Pln+0x845>
mov    %rbp,0x50(%rsp)
shl    $0x4,%rbp
mov    0x158(%rsp),%rax
movsd  (%rax,%rbp,1),%xmm0
mov    %r11d,%edi
mov    0x40(%rsp),%rsi
mov    0xa0(%rsp),%r14
mov    %r14,%rdx
call   1040 <FindSpan@plt>
mov    0x158(%rsp),%rcx
movsd  (%rcx,%rbp,1),%xmm0
mov    %rax,0x30(%rsp)
mov    %eax,%edi
mov    0x40(%rsp),%rsi
mov    %r14,%rdx
mov    0x1b0(%rsp),%rcx
mov    0x1a0(%rsp),%r8
mov    0x1a8(%rsp),%r9
call   1030 <BasisFuns@plt>
mov    0x158(%rsp),%rax
movsd  0x8(%rax,%rbp,1),%xmm0
mov    %rax,%r14
mov    0x70(%rsp),%edi
mov    0x20(%rsp),%rsi
mov    0x150(%rsp),%rdx
call   1040 <FindSpan@plt>
movsd  0x8(%r14,%rbp,1),%xmm0
mov    0x40(%rsp),%r14
mov    %rax,0x8(%rsp)
mov    %eax,%edi
mov    0x20(%rsp),%rbp
mov    %ebp,%esi
mov    0x150(%rsp),%rdx
mov    0x1c8(%rsp),%rcx
mov    0x1b8(%rsp),%r8
mov    0x1c0(%rsp),%r9
call   1030 <BasisFuns@plt>
mov    0x78(%rsp),%r11
test   %ebp,%ebp
mov    0x168(%rsp),%r8
js     18c0 <computeLinGNmatPnt2Pln+0x7a0>
mov    0x50(%rsp),%r9
lea    (%r9,%r9,2),%rax
lea    0x2(%rax),%edx
lea    0x1(%rax),%esi
mov    0x30(%rsp),%rbp
mov    %ebp,%ecx
sub    %r14d,%ecx
mov    %ecx,0x14(%rsp)
mov    0x8(%rsp),%rcx
mov    %ecx,%edi
sub    0x20(%rsp),%edi
mov    %rdi,0x18(%rsp)
lea    (%r8,%rdx,8),%rdi
mov    %rdi,0xf0(%rsp)
mov    0x88(%rsp),%rdi
lea    (%rdi,%rdx,8),%rdx
mov    %rdx,0xe8(%rsp)
lea    (%r8,%rsi,8),%rdx
mov    %rdx,0xe0(%rsp)
lea    (%rdi,%rsi,8),%rdx
mov    %rdx,0xd8(%rsp)
mov    %eax,%eax
lea    (%r8,%rax,8),%rdx
mov    %rdx,0xd0(%rsp)
lea    (%rdi,%rax,8),%rax
mov    %rax,0xc8(%rsp)
lea    (%r9,%r9,2),%eax
mov    %rax,0x38(%rsp)
add    0x60(%rsp),%ecx
mov    0x2c(%rsp),%eax
mov    %rcx,0x8(%rsp)
imul   %ecx,%eax
add    0x64(%rsp),%eax
lea    (%rax,%rbp,4),%edi
xorpd  %xmm0,%xmm0
xor    %edx,%edx
mov    0x48(%rsp),%r10
mov    0x90(%rsp),%rcx
mov    %rbp,%rsi
mov    %rbp,%r9
jmp    1445 <computeLinGNmatPnt2Pln+0x325>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rdx
add    0x110(%rsp),%rdi
cmp    %r15,%rdx
je     1510 <computeLinGNmatPnt2Pln+0x3f0>
test   %r14d,%r14d
js     1430 <computeLinGNmatPnt2Pln+0x310>
mov    0x1c8(%rsp),%rax
movsd  (%rax,%rdx,8),%xmm1
je     14c0 <computeLinGNmatPnt2Pln+0x3a0>
xor    %esi,%esi
xor    %eax,%eax
mov    0x1b0(%rsp),%r8
cs nopw 0x0(%rax,%rax,1)
nop
movsd  (%r8,%rsi,2),%xmm2
mulsd  %xmm1,%xmm2
lea    (%rdi,%rsi,1),%ebp
add    $0x3,%ebp
movslq %ebp,%rbp
mulsd  0x0(%r13,%rbp,8),%xmm2
addsd  %xmm0,%xmm2
movsd  0x8(%r8,%rsi,2),%xmm0
mulsd  %xmm1,%xmm0
lea    0x7(%rdi,%rsi,1),%ebp
movslq %ebp,%rbp
mulsd  0x0(%r13,%rbp,8),%xmm0
addsd  %xmm2,%xmm0
add    $0x2,%rax
add    $0x8,%rsi
cmp    %rsi,%rcx
jne    1470 <computeLinGNmatPnt2Pln+0x350>
jmp    14c2 <computeLinGNmatPnt2Pln+0x3a2>
nopw   0x0(%rax,%rax,1)
xor    %eax,%eax
test   $0x1,%r10b
mov    %r9,%rsi
je     1430 <computeLinGNmatPnt2Pln+0x310>
mov    0x18(%rsp),%rsi
add    %edx,%esi
mov    0x1b0(%rsp),%rbp
mulsd  0x0(%rbp,%rax,8),%xmm1
imul   0x2c(%rsp),%esi
add    0x14(%rsp),%eax
lea    (%rsi,%rax,4),%eax
mov    %r9,%rsi
or     $0x3,%eax
cltq
mulsd  0x0(%r13,%rax,8),%xmm1
addsd  %xmm1,%xmm0
jmp    1430 <computeLinGNmatPnt2Pln+0x310>
nopl   0x0(%rax,%rax,1)
cmpl   $0x0,0x20(%rsp)
mov    0x38(%rsp),%rax
js     18c0 <computeLinGNmatPnt2Pln+0x7a0>
mov    %eax,%ecx
mov    %rcx,0x30(%rsp)
lea    0x1(%rax),%ecx
mov    %rcx,0x80(%rsp)
add    $0x2,%eax
mov    %rax,0x38(%rsp)
mov    0x18(%rsp),%rax
imul   %r11d,%eax
add    %eax,0x14(%rsp)
movapd %xmm0,%xmm8
unpcklpd %xmm0,%xmm8
add    0x5c(%rsp),%esi
mov    0x8(%rsp),%rax
imul   %r11d,%eax
add    %esi,%eax
mov    %rax,0x8(%rsp)
xor    %r9d,%r9d
xor    %r8d,%r8d
jmp    159c <computeLinGNmatPnt2Pln+0x47c>
nopl   (%rax)
mov    0x78(%rsp),%r11
mov    0x40(%rsp),%r14
mov    0x108(%rsp),%r15
add    $0x1,%r9
mov    0x8(%rsp),%rax
add    %r11d,%eax
mov    %rax,0x8(%rsp)
cmp    %r15,%r9
je     18c0 <computeLinGNmatPnt2Pln+0x7a0>
test   %r14d,%r14d
js     1582 <computeLinGNmatPnt2Pln+0x462>
movslq 0x8(%rsp),%r10
movslq %r8d,%rsi
cmpl   $0x2,0x74(%rsp)
jb     17d0 <computeLinGNmatPnt2Pln+0x6b0>
mov    %r9d,%eax
imul   %r11d,%eax
add    0x14(%rsp),%eax
cltq
shl    $0x3,%rax
lea    (%rax,%rax,2),%rbp
mov    0x170(%rsp),%rax
lea    (%rax,%rbp,1),%r8
add    0xc0(%rsp),%rbp
mov    0x1c8(%rsp),%rcx
lea    (%rcx,%r9,8),%rax
lea    (%rcx,%r9,8),%rdx
add    $0x8,%rdx
lea    (%rbx,%rsi,8),%r14
mov    0xb8(%rsp),%rcx
lea    (%rcx,%rsi,8),%r11
cmp    %rdx,%r14
setb   %r15b
cmp    %r11,%rax
setb   0x18(%rsp)
cmp    0xb0(%rsp),%r14
setb   %al
cmp    0x1b0(%rsp),%r11
seta   0x7(%rsp)
cmp    0xe8(%rsp),%r14
setb   %cl
cmp    %r11,0xf0(%rsp)
setb   0x6(%rsp)
cmp    0xd8(%rsp),%r14
setb   %dl
cmp    %r11,0xe0(%rsp)
setb   0x5(%rsp)
cmp    0xc8(%rsp),%r14
setb   %dil
cmp    %r11,0xd0(%rsp)
setb   0x4(%rsp)
cmp    %rbp,%r14
setb   %bpl
cmp    %r11,%r8
setb   %r8b
test   %r15b,0x18(%rsp)
jne    17d0 <computeLinGNmatPnt2Pln+0x6b0>
and    0x7(%rsp),%al
jne    17d0 <computeLinGNmatPnt2Pln+0x6b0>
and    0x6(%rsp),%cl
jne    17d0 <computeLinGNmatPnt2Pln+0x6b0>
and    0x5(%rsp),%dl
jne    17d0 <computeLinGNmatPnt2Pln+0x6b0>
and    0x4(%rsp),%dil
jne    17d0 <computeLinGNmatPnt2Pln+0x6b0>
and    %r8b,%bpl
jne    17d0 <computeLinGNmatPnt2Pln+0x6b0>
lea    (%r10,%r10,2),%rax
mov    0x170(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
mov    0xa8(%rsp),%rcx
lea    (%rcx,%rsi,1),%r8
mov    0x1c8(%rsp),%rdx
movsd  (%rdx,%r9,8),%xmm9
unpcklpd %xmm9,%xmm9
mov    0x168(%rsp),%rdx
mov    0x30(%rsp),%rdi
movsd  (%rdx,%rdi,8),%xmm10
unpcklpd %xmm10,%xmm10
mov    0x80(%rsp),%rdi
movsd  (%rdx,%rdi,8),%xmm4
unpcklpd %xmm4,%xmm4
mov    0x38(%rsp),%rdi
movsd  (%rdx,%rdi,8),%xmm5
unpcklpd %xmm5,%xmm5
mov    0x190(%rsp),%rdx
lea    (%rdx,%rsi,4),%rdx
xor    %r11d,%r11d
mov    0x1b0(%rsp),%r15
mov    0x8(%rsp),%rbp
xchg   %ax,%ax
lea    (%r11,%rbp,1),%esi
lea    (%r11,%rbp,1),%edi
add    $0x1,%edi
movd   %edi,%xmm6
movd   %esi,%xmm7
punpckldq %xmm6,%xmm7
movq   %xmm7,(%rdx,%r11,4)
movupd (%r15,%r11,8),%xmm6
mulpd  %xmm9,%xmm6
movupd (%rax),%xmm7
movupd 0x10(%rax),%xmm3
movupd 0x20(%rax),%xmm2
movapd %xmm3,%xmm1
movsd  %xmm7,%xmm1
mulpd  %xmm10,%xmm1
shufpd $0x1,%xmm2,%xmm7
mulpd  %xmm4,%xmm7
addpd  %xmm1,%xmm7
movsd  %xmm3,%xmm2
mulpd  %xmm5,%xmm2
addpd  %xmm7,%xmm2
mulpd  %xmm6,%xmm2
divpd  %xmm8,%xmm2
movupd %xmm2,(%r14,%r11,8)
add    $0x2,%r11
add    $0x30,%rax
cmp    %r11,%rcx
jne    1740 <computeLinGNmatPnt2Pln+0x620>
mov    %rcx,%rax
cmp    0x48(%rsp),%rcx
je     1570 <computeLinGNmatPnt2Pln+0x450>
jmp    17d5 <computeLinGNmatPnt2Pln+0x6b5>
nopl   0x0(%rax,%rax,1)
mov    %rsi,%r8
xor    %eax,%eax
mov    0x190(%rsp),%rcx
lea    (%rcx,%r8,4),%r11
mov    %r8,0x18(%rsp)
lea    (%rbx,%r8,8),%rcx
lea    (%rax,%r10,1),%edx
add    %rax,%r10
lea    (%r10,%r10,2),%rsi
mov    0x100(%rsp),%rdi
lea    (%rdi,%rsi,8),%rsi
mov    0x1b0(%rsp),%rdi
lea    (%rdi,%rax,8),%rbp
mov    0x48(%rsp),%rdi
sub    %rax,%rdi
xor    %ebx,%ebx
mov    0x1c8(%rsp),%r15
mov    0x168(%rsp),%r14
mov    0x38(%rsp),%r10
mov    0x30(%rsp),%r8
mov    0x80(%rsp),%r13
nopl   0x0(%rax)
lea    (%rdx,%rbx,1),%eax
mov    %eax,(%r11,%rbx,4)
movsd  (%r15,%r9,8),%xmm1
mulsd  0x0(%rbp,%rbx,8),%xmm1
movsd  (%r14,%r8,8),%xmm2
movsd  (%r14,%r13,8),%xmm3
mulsd  -0x8(%rsi),%xmm3
mulsd  -0x10(%rsi),%xmm2
movsd  (%r14,%r10,8),%xmm4
mulsd  (%rsi),%xmm4
addsd  %xmm3,%xmm2
addsd  %xmm2,%xmm4
mulsd  %xmm1,%xmm4
divsd  %xmm0,%xmm4
movsd  %xmm4,(%rcx,%rbx,8)
add    $0x1,%rbx
add    $0x18,%rsi
cmp    %rbx,%rdi
jne    1840 <computeLinGNmatPnt2Pln+0x720>
mov    0x18(%rsp),%r8
add    %rbx,%r8
mov    0x198(%rsp),%rbx
mov    0xf8(%rsp),%r13
jmp    1570 <computeLinGNmatPnt2Pln+0x450>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmpl   $0x0,0x68(%rsp)
mov    0x180(%rsp),%rbp
mov    0x6c(%rsp),%r8d
jle    1270 <computeLinGNmatPnt2Pln+0x150>
xor    %eax,%eax
jmp    18ed <computeLinGNmatPnt2Pln+0x7cd>
nopl   0x0(%rax)
add    $0x1,%rax
cmp    %r12,%rax
je     1270 <computeLinGNmatPnt2Pln+0x150>
mov    0x178(%rsp),%rcx
mov    0x50(%rsp),%rdx
movsd  (%rcx,%rdx,8),%xmm0
mov    0x190(%rsp),%rcx
movslq (%rcx,%rax,4),%rcx
mulsd  (%rbx,%rax,8),%xmm0
mov    0x188(%rsp),%rdx
addsd  (%rdx,%rcx,8),%xmm0
movsd  %xmm0,(%rdx,%rcx,8)
mov    %ecx,%edx
imul   %r8d,%edx
xor    %esi,%esi
jmp    1939 <computeLinGNmatPnt2Pln+0x819>
nopl   0x0(%rax)
add    $0x1,%rsi
cmp    %rsi,%r12
je     18e0 <computeLinGNmatPnt2Pln+0x7c0>
mov    0x190(%rsp),%rdi
mov    (%rdi,%rsi,4),%edi
cmp    %ecx,%edi
jl     1930 <computeLinGNmatPnt2Pln+0x810>
movsd  (%rbx,%rax,8),%xmm0
add    %edx,%edi
mulsd  (%rbx,%rsi,8),%xmm0
movslq %edi,%rdi
addsd  0x0(%rbp,%rdi,8),%xmm0
movsd  %xmm0,0x0(%rbp,%rdi,8)
jmp    1930 <computeLinGNmatPnt2Pln+0x810>
cmp    $0x2,%r8d
jl     1a45 <computeLinGNmatPnt2Pln+0x925>
mov    %r8d,%r9d
mov    0x180(%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    19c8 <computeLinGNmatPnt2Pln+0x8a8>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%r11
add    $0x1,%r10
add    $0x8,%rsi
add    %r8,%rcx
add    $0x8,%rdi
cmp    %r9,%r11
je     1a45 <computeLinGNmatPnt2Pln+0x925>
test   %r10,%r10
je     1a10 <computeLinGNmatPnt2Pln+0x8f0>
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    19e0 <computeLinGNmatPnt2Pln+0x8c0>
test   $0x1,%r11b
je     19b0 <computeLinGNmatPnt2Pln+0x890>
jmp    1a18 <computeLinGNmatPnt2Pln+0x8f8>
nopl   0x0(%rax)
xor    %edx,%edx
test   $0x1,%r11b
je     19b0 <computeLinGNmatPnt2Pln+0x890>
mov    %r11,%rbx
imul   %r9,%rbx
mov    %rdx,%rax
imul   %r9,%rax
add    %r11,%rax
mov    0x180(%rsp),%rbp
movsd  0x0(%rbp,%rax,8),%xmm0
add    %rdx,%rbx
movsd  %xmm0,0x0(%rbp,%rbx,8)
jmp    19b0 <computeLinGNmatPnt2Pln+0x890>
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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