#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*/ findNURBSbasisFunIso4xScCP(int, int, double, double, int,
                                              double *, double, double, int,
                                              int, double *, int, int, double *,
                                              double *, double *, double *,
                                              double *, double *, double *,
                                              double *, double *, double *);
void NURBSsurfaceBasisX4ScMax(int degU, int degV, double *cp, int ncp, int kcp,
                              double *knotU, double *knotV, double *us,
                              double *usX1max, double *basisVals, double *leftU,
                              double *rightU, double *NU, double *leftV,
                              double *rightV, double *NV) {
  int ii, jj, nus, orderU, orderV;
  double uv[2], stepU, stepV;
  orderU = degU + 1;
  orderV = degV + 1;
  nus = 0;
  for (ii = 0; ii <= (kcp - 2); ii++) {
    stepV = 0.1 * (knotV[ii + 1 + orderV] - knotV[ii]);
    for (jj = 0; jj <= (ncp - 2); jj++) {
      stepU = 0.1 * (knotU[jj + 1 + orderU] - knotU[jj]);
      uv[0] = 0.75 * (0.75 * usX1max[2 * (ii * ncp + jj)] +
                      0.25 * usX1max[2 * (ii * ncp + jj + 1)]) +
              0.25 * (0.75 * usX1max[2 * ((ii + 1) * ncp + jj)] +
                      0.25 * usX1max[2 * ((ii + 1) * ncp + jj + 1)]);
      uv[1] = 0.75 * (0.75 * usX1max[2 * (ii * ncp + jj) + 1] +
                      0.25 * usX1max[2 * (ii * ncp + jj + 1) + 1]) +
              0.25 * (0.75 * usX1max[2 * ((ii + 1) * ncp + jj) + 1] +
                      0.25 * usX1max[2 * ((ii + 1) * ncp + jj + 1) + 1]);
      findNURBSbasisFunIso4xScCP(ii, jj, 0.75, 0.75, 12, uv, stepU, stepV, degU,
                                 degV, cp, ncp, kcp, knotU, knotV, usX1max,
                                 basisVals, leftU, rightU, NU, leftV, rightV,
                                 NV);
      us[2 * nus] = uv[0];
      us[2 * nus + 1] = uv[1];
      nus++;
      uv[0] = 0.75 * (0.5 * usX1max[2 * (ii * ncp + jj)] +
                      0.5 * usX1max[2 * (ii * ncp + jj + 1)]) +
              0.25 * (0.5 * usX1max[2 * ((ii + 1) * ncp + jj)] +
                      0.5 * usX1max[2 * ((ii + 1) * ncp + jj + 1)]);
      uv[1] = 0.75 * (0.5 * usX1max[2 * (ii * ncp + jj) + 1] +
                      0.5 * usX1max[2 * (ii * ncp + jj + 1) + 1]) +
              0.25 * (0.5 * usX1max[2 * ((ii + 1) * ncp + jj) + 1] +
                      0.5 * usX1max[2 * ((ii + 1) * ncp + jj + 1) + 1]);
      findNURBSbasisFunIso4xScCP(ii, jj, 0.75, 0.5, 12, uv, stepU, stepV, degU,
                                 degV, cp, ncp, kcp, knotU, knotV, usX1max,
                                 basisVals, leftU, rightU, NU, leftV, rightV,
                                 NV);
      us[2 * nus] = uv[0];
      us[2 * nus + 1] = uv[1];
      nus++;
      uv[0] = 0.75 * (0.25 * usX1max[2 * (ii * ncp + jj)] +
                      0.75 * usX1max[2 * (ii * ncp + jj + 1)]) +
              0.25 * (0.25 * usX1max[2 * ((ii + 1) * ncp + jj)] +
                      0.75 * usX1max[2 * ((ii + 1) * ncp + jj + 1)]);
      uv[1] = 0.75 * (0.25 * usX1max[2 * (ii * ncp + jj) + 1] +
                      0.75 * usX1max[2 * (ii * ncp + jj + 1) + 1]) +
              0.25 * (0.25 * usX1max[2 * ((ii + 1) * ncp + jj) + 1] +
                      0.75 * usX1max[2 * ((ii + 1) * ncp + jj + 1) + 1]);
      findNURBSbasisFunIso4xScCP(ii, jj, 0.75, 0.25, 12, uv, stepU, stepV, degU,
                                 degV, cp, ncp, kcp, knotU, knotV, usX1max,
                                 basisVals, leftU, rightU, NU, leftV, rightV,
                                 NV);
      us[2 * nus] = uv[0];
      us[2 * nus + 1] = uv[1];
      nus++;
      uv[0] = 0.5 * (0.75 * usX1max[2 * (ii * ncp + jj)] +
                     0.25 * usX1max[2 * (ii * ncp + jj + 1)]) +
              0.5 * (0.75 * usX1max[2 * ((ii + 1) * ncp + jj)] +
                     0.25 * usX1max[2 * ((ii + 1) * ncp + jj + 1)]);
      uv[1] = 0.5 * (0.75 * usX1max[2 * (ii * ncp + jj) + 1] +
                     0.25 * usX1max[2 * (ii * ncp + jj + 1) + 1]) +
              0.5 * (0.75 * usX1max[2 * ((ii + 1) * ncp + jj) + 1] +
                     0.25 * usX1max[2 * ((ii + 1) * ncp + jj + 1) + 1]);
      findNURBSbasisFunIso4xScCP(ii, jj, 0.5, 0.75, 12, uv, stepU, stepV, degU,
                                 degV, cp, ncp, kcp, knotU, knotV, usX1max,
                                 basisVals, leftU, rightU, NU, leftV, rightV,
                                 NV);
      us[2 * nus] = uv[0];
      us[2 * nus + 1] = uv[1];
      nus++;
      uv[0] = 0.5 * (0.25 * usX1max[2 * (ii * ncp + jj)] +
                     0.75 * usX1max[2 * (ii * ncp + jj + 1)]) +
              0.5 * (0.25 * usX1max[2 * ((ii + 1) * ncp + jj)] +
                     0.75 * usX1max[2 * ((ii + 1) * ncp + jj + 1)]);
      uv[1] = 0.5 * (0.25 * usX1max[2 * (ii * ncp + jj) + 1] +
                     0.75 * usX1max[2 * (ii * ncp + jj + 1) + 1]) +
              0.5 * (0.25 * usX1max[2 * ((ii + 1) * ncp + jj) + 1] +
                     0.75 * usX1max[2 * ((ii + 1) * ncp + jj + 1) + 1]);
      findNURBSbasisFunIso4xScCP(ii, jj, 0.5, 0.25, 12, uv, stepU, stepV, degU,
                                 degV, cp, ncp, kcp, knotU, knotV, usX1max,
                                 basisVals, leftU, rightU, NU, leftV, rightV,
                                 NV);
      us[2 * nus] = uv[0];
      us[2 * nus + 1] = uv[1];
      nus++;
      uv[0] = 0.25 * (0.75 * usX1max[2 * (ii * ncp + jj)] +
                      0.25 * usX1max[2 * (ii * ncp + jj + 1)]) +
              0.75 * (0.75 * usX1max[2 * ((ii + 1) * ncp + jj)] +
                      0.25 * usX1max[2 * ((ii + 1) * ncp + jj + 1)]);
      uv[1] = 0.25 * (0.75 * usX1max[2 * (ii * ncp + jj) + 1] +
                      0.25 * usX1max[2 * (ii * ncp + jj + 1) + 1]) +
              0.75 * (0.75 * usX1max[2 * ((ii + 1) * ncp + jj) + 1] +
                      0.25 * usX1max[2 * ((ii + 1) * ncp + jj + 1) + 1]);
      findNURBSbasisFunIso4xScCP(ii, jj, 0.25, 0.75, 12, uv, stepU, stepV, degU,
                                 degV, cp, ncp, kcp, knotU, knotV, usX1max,
                                 basisVals, leftU, rightU, NU, leftV, rightV,
                                 NV);
      us[2 * nus] = uv[0];
      us[2 * nus + 1] = uv[1];
      nus++;
      uv[0] = 0.25 * (0.5 * usX1max[2 * (ii * ncp + jj)] +
                      0.5 * usX1max[2 * (ii * ncp + jj + 1)]) +
              0.75 * (0.5 * usX1max[2 * ((ii + 1) * ncp + jj)] +
                      0.5 * usX1max[2 * ((ii + 1) * ncp + jj + 1)]);
      uv[1] = 0.25 * (0.5 * usX1max[2 * (ii * ncp + jj) + 1] +
                      0.5 * usX1max[2 * (ii * ncp + jj + 1) + 1]) +
              0.75 * (0.5 * usX1max[2 * ((ii + 1) * ncp + jj) + 1] +
                      0.5 * usX1max[2 * ((ii + 1) * ncp + jj + 1) + 1]);
      findNURBSbasisFunIso4xScCP(ii, jj, 0.25, 0.5, 12, uv, stepU, stepV, degU,
                                 degV, cp, ncp, kcp, knotU, knotV, usX1max,
                                 basisVals, leftU, rightU, NU, leftV, rightV,
                                 NV);
      us[2 * nus] = uv[0];
      us[2 * nus + 1] = uv[1];
      nus++;
      uv[0] = 0.25 * (0.25 * usX1max[2 * (ii * ncp + jj)] +
                      0.75 * usX1max[2 * (ii * ncp + jj + 1)]) +
              0.75 * (0.25 * usX1max[2 * ((ii + 1) * ncp + jj)] +
                      0.75 * usX1max[2 * ((ii + 1) * ncp + jj + 1)]);
      uv[1] = 0.25 * (0.25 * usX1max[2 * (ii * ncp + jj) + 1] +
                      0.75 * usX1max[2 * (ii * ncp + jj + 1) + 1]) +
              0.75 * (0.25 * usX1max[2 * ((ii + 1) * ncp + jj) + 1] +
                      0.75 * usX1max[2 * ((ii + 1) * ncp + jj + 1) + 1]);
      findNURBSbasisFunIso4xScCP(ii, jj, 0.25, 0.25, 12, uv, stepU, stepV, degU,
                                 degV, cp, ncp, kcp, knotU, knotV, usX1max,
                                 basisVals, leftU, rightU, NU, leftV, rightV,
                                 NV);
      us[2 * nus] = uv[0];
      us[2 * nus + 1] = uv[1];
      nus++;
    }
  }
}


x86 assembly (clang, -O0):
<NURBSsurfaceBasisX4ScMax>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1c8,%rsp
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),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x2c(%rbp)
mov    %esi,-0x30(%rbp)
mov    %rdx,-0x38(%rbp)
mov    %ecx,-0x3c(%rbp)
mov    %r8d,-0x40(%rbp)
mov    %r9,-0x48(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x58(%rbp)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x5c(%rbp)
movl   $0x0,-0x54(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     27a7 <NURBSsurfaceBasisX4ScMax+0x1697>
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
add    -0x5c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x10(%rbp),%rax
movslq -0x4c(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
movsd  0x1e44(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%rbp)
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x3c(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     2794 <NURBSsurfaceBasisX4ScMax+0x1684>
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
add    -0x58(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x48(%rbp),%rax
movslq -0x50(%rbp),%rcx
subsd  (%rax,%rcx,8),%xmm1
movsd  0x1df9(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x1dc0(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x1dbb(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x1d6d(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x1d68(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x1d50(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x1d4c(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x1cf9(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x1cf4(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x1ca0(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x1c9b(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x1c83(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x1c7f(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x4c(%rbp),%edi
mov    -0x50(%rbp),%esi
lea    -0x70(%rbp),%rcx
movsd  -0x78(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm3
mov    -0x2c(%rbp),%r8d
mov    -0x30(%rbp),%r9d
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%edx
mov    %edx,-0x180(%rbp)
mov    -0x40(%rbp),%edx
mov    %edx,-0x17c(%rbp)
mov    -0x48(%rbp),%rdx
mov    %rdx,-0x178(%rbp)
mov    0x10(%rbp),%rdx
mov    %rdx,-0x170(%rbp)
mov    0x20(%rbp),%r13
mov    0x28(%rbp),%r12
mov    0x30(%rbp),%r15
mov    0x38(%rbp),%r14
mov    0x40(%rbp),%rbx
mov    0x48(%rbp),%r11
mov    0x50(%rbp),%r10
mov    0x58(%rbp),%rdx
mov    %rdx,-0x168(%rbp)
movsd  0x1bfb(%rip),%xmm1
mov    $0xc,%edx
movaps %xmm1,%xmm0
mov    %rax,(%rsp)
mov    -0x180(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0x17c(%rbp),%eax
mov    %eax,0x10(%rsp)
mov    -0x178(%rbp),%rax
mov    %rax,0x18(%rsp)
mov    -0x170(%rbp),%rax
mov    %rax,0x20(%rsp)
mov    -0x168(%rbp),%rax
mov    %r13,0x28(%rsp)
mov    %r12,0x30(%rsp)
mov    %r15,0x38(%rsp)
mov    %r14,0x40(%rsp)
mov    %rbx,0x48(%rsp)
mov    %r11,0x50(%rsp)
mov    %r10,0x58(%rsp)
mov    %rax,0x60(%rsp)
call   1030 <findNURBSbasisFunIso4xScCP@plt>
movsd  -0x70(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x1b25(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x1b18(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x1ad2(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x1ac5(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x1aa5(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x1aa1(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x1a5e(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x1a51(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x1a05(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x19f8(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x19d8(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x19d4(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x4c(%rbp),%edi
mov    -0x50(%rbp),%esi
lea    -0x70(%rbp),%rcx
movsd  -0x78(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm3
mov    -0x2c(%rbp),%r8d
mov    -0x30(%rbp),%r9d
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%edx
mov    %edx,-0x160(%rbp)
mov    -0x40(%rbp),%edx
mov    %edx,-0x15c(%rbp)
mov    -0x48(%rbp),%rdx
mov    %rdx,-0x158(%rbp)
mov    0x10(%rbp),%rdx
mov    %rdx,-0x150(%rbp)
mov    0x20(%rbp),%r13
mov    0x28(%rbp),%r12
mov    0x30(%rbp),%r15
mov    0x38(%rbp),%r14
mov    0x40(%rbp),%rbx
mov    0x48(%rbp),%r11
mov    0x50(%rbp),%r10
mov    0x58(%rbp),%rdx
mov    %rdx,-0x148(%rbp)
movsd  0x1950(%rip),%xmm0
movsd  0x1950(%rip),%xmm1
mov    $0xc,%edx
mov    %rax,(%rsp)
mov    -0x160(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0x15c(%rbp),%eax
mov    %eax,0x10(%rsp)
mov    -0x158(%rbp),%rax
mov    %rax,0x18(%rsp)
mov    -0x150(%rbp),%rax
mov    %rax,0x20(%rsp)
mov    -0x148(%rbp),%rax
mov    %r13,0x28(%rsp)
mov    %r12,0x30(%rsp)
mov    %r15,0x38(%rsp)
mov    %r14,0x40(%rsp)
mov    %rbx,0x48(%rsp)
mov    %r11,0x50(%rsp)
mov    %r10,0x58(%rsp)
mov    %rax,0x60(%rsp)
call   1030 <findNURBSbasisFunIso4xScCP@plt>
movsd  -0x70(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x186d(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x1858(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x181a(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x1805(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x17f5(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x17f1(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x17a6(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x1791(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x174d(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x1738(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x1728(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x1724(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x4c(%rbp),%edi
mov    -0x50(%rbp),%esi
lea    -0x70(%rbp),%rcx
movsd  -0x78(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm3
mov    -0x2c(%rbp),%r8d
mov    -0x30(%rbp),%r9d
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%edx
mov    %edx,-0x140(%rbp)
mov    -0x40(%rbp),%edx
mov    %edx,-0x13c(%rbp)
mov    -0x48(%rbp),%rdx
mov    %rdx,-0x138(%rbp)
mov    0x10(%rbp),%rdx
mov    %rdx,-0x130(%rbp)
mov    0x20(%rbp),%r13
mov    0x28(%rbp),%r12
mov    0x30(%rbp),%r15
mov    0x38(%rbp),%r14
mov    0x40(%rbp),%rbx
mov    0x48(%rbp),%r11
mov    0x50(%rbp),%r10
mov    0x58(%rbp),%rdx
mov    %rdx,-0x128(%rbp)
movsd  0x16a0(%rip),%xmm0
movsd  0x1690(%rip),%xmm1
mov    $0xc,%edx
mov    %rax,(%rsp)
mov    -0x140(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0x13c(%rbp),%eax
mov    %eax,0x10(%rsp)
mov    -0x138(%rbp),%rax
mov    %rax,0x18(%rsp)
mov    -0x130(%rbp),%rax
mov    %rax,0x20(%rsp)
mov    -0x128(%rbp),%rax
mov    %r13,0x28(%rsp)
mov    %r12,0x30(%rsp)
mov    %r15,0x38(%rsp)
mov    %r14,0x40(%rsp)
mov    %rbx,0x48(%rsp)
mov    %r11,0x50(%rsp)
mov    %r10,0x58(%rsp)
mov    %rax,0x60(%rsp)
call   1030 <findNURBSbasisFunIso4xScCP@plt>
movsd  -0x70(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x15b5(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x15b0(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x1562(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x155d(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x1555(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x1549(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x14ee(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x14e9(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x1495(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x1490(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x1488(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x147c(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x4c(%rbp),%edi
mov    -0x50(%rbp),%esi
lea    -0x70(%rbp),%rcx
movsd  -0x78(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm3
mov    -0x2c(%rbp),%r8d
mov    -0x30(%rbp),%r9d
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%edx
mov    %edx,-0x120(%rbp)
mov    -0x40(%rbp),%edx
mov    %edx,-0x11c(%rbp)
mov    -0x48(%rbp),%rdx
mov    %rdx,-0x118(%rbp)
mov    0x10(%rbp),%rdx
mov    %rdx,-0x110(%rbp)
mov    0x20(%rbp),%r13
mov    0x28(%rbp),%r12
mov    0x30(%rbp),%r15
mov    0x38(%rbp),%r14
mov    0x40(%rbp),%rbx
mov    0x48(%rbp),%r11
mov    0x50(%rbp),%r10
mov    0x58(%rbp),%rdx
mov    %rdx,-0x108(%rbp)
movsd  0x13f8(%rip),%xmm0
movsd  0x13e8(%rip),%xmm1
mov    $0xc,%edx
mov    %rax,(%rsp)
mov    -0x120(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0x11c(%rbp),%eax
mov    %eax,0x10(%rsp)
mov    -0x118(%rbp),%rax
mov    %rax,0x18(%rsp)
mov    -0x110(%rbp),%rax
mov    %rax,0x20(%rsp)
mov    -0x108(%rbp),%rax
mov    %r13,0x28(%rsp)
mov    %r12,0x30(%rsp)
mov    %r15,0x38(%rsp)
mov    %r14,0x40(%rsp)
mov    %rbx,0x48(%rsp)
mov    %r11,0x50(%rsp)
mov    %r10,0x58(%rsp)
mov    %rax,0x60(%rsp)
call   1030 <findNURBSbasisFunIso4xScCP@plt>
movsd  -0x70(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x130d(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x12f8(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x12ba(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x12a5(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x12a5(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x1299(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x1246(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x1231(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x11ed(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x11d8(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x11d8(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x11cc(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x4c(%rbp),%edi
mov    -0x50(%rbp),%esi
lea    -0x70(%rbp),%rcx
movsd  -0x78(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm3
mov    -0x2c(%rbp),%r8d
mov    -0x30(%rbp),%r9d
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%edx
mov    %edx,-0x100(%rbp)
mov    -0x40(%rbp),%edx
mov    %edx,-0xfc(%rbp)
mov    -0x48(%rbp),%rdx
mov    %rdx,-0xf8(%rbp)
mov    0x10(%rbp),%rdx
mov    %rdx,-0xf0(%rbp)
mov    0x20(%rbp),%r13
mov    0x28(%rbp),%r12
mov    0x30(%rbp),%r15
mov    0x38(%rbp),%r14
mov    0x40(%rbp),%rbx
mov    0x48(%rbp),%r11
mov    0x50(%rbp),%r10
mov    0x58(%rbp),%rdx
mov    %rdx,-0xe8(%rbp)
movsd  0x1148(%rip),%xmm0
movsd  0x1130(%rip),%xmm1
mov    $0xc,%edx
mov    %rax,(%rsp)
mov    -0x100(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0xfc(%rbp),%eax
mov    %eax,0x10(%rsp)
mov    -0xf8(%rbp),%rax
mov    %rax,0x18(%rsp)
mov    -0xf0(%rbp),%rax
mov    %rax,0x20(%rsp)
mov    -0xe8(%rbp),%rax
mov    %r13,0x28(%rsp)
mov    %r12,0x30(%rsp)
mov    %r15,0x38(%rsp)
mov    %r14,0x40(%rsp)
mov    %rbx,0x48(%rsp)
mov    %r11,0x50(%rsp)
mov    %r10,0x58(%rsp)
mov    %rax,0x60(%rsp)
call   1030 <findNURBSbasisFunIso4xScCP@plt>
movsd  -0x70(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x1055(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x1050(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x1002(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0xffd(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0xfed(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0xfd9(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xf8e(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0xf89(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xf35(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0xf30(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0xf20(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0xf0c(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x4c(%rbp),%edi
mov    -0x50(%rbp),%esi
lea    -0x70(%rbp),%rcx
movsd  -0x78(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm3
mov    -0x2c(%rbp),%r8d
mov    -0x30(%rbp),%r9d
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%edx
mov    %edx,-0xe0(%rbp)
mov    -0x40(%rbp),%edx
mov    %edx,-0xdc(%rbp)
mov    -0x48(%rbp),%rdx
mov    %rdx,-0xd8(%rbp)
mov    0x10(%rbp),%rdx
mov    %rdx,-0xd0(%rbp)
mov    0x20(%rbp),%r13
mov    0x28(%rbp),%r12
mov    0x30(%rbp),%r15
mov    0x38(%rbp),%r14
mov    0x40(%rbp),%rbx
mov    0x48(%rbp),%r11
mov    0x50(%rbp),%r10
mov    0x58(%rbp),%rdx
mov    %rdx,-0xc8(%rbp)
movsd  0xe88(%rip),%xmm0
movsd  0xe88(%rip),%xmm1
mov    $0xc,%edx
mov    %rax,(%rsp)
mov    -0xe0(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0xdc(%rbp),%eax
mov    %eax,0x10(%rsp)
mov    -0xd8(%rbp),%rax
mov    %rax,0x18(%rsp)
mov    -0xd0(%rbp),%rax
mov    %rax,0x20(%rsp)
mov    -0xc8(%rbp),%rax
mov    %r13,0x28(%rsp)
mov    %r12,0x30(%rsp)
mov    %r15,0x38(%rsp)
mov    %r14,0x40(%rsp)
mov    %rbx,0x48(%rsp)
mov    %r11,0x50(%rsp)
mov    %r10,0x58(%rsp)
mov    %rax,0x60(%rsp)
call   1030 <findNURBSbasisFunIso4xScCP@plt>
movsd  -0x70(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xdb5(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0xda8(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xd62(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0xd55(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0xd3d(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0xd29(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xcee(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0xce1(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xc95(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0xc88(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0xc70(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0xc5c(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x4c(%rbp),%edi
mov    -0x50(%rbp),%esi
lea    -0x70(%rbp),%rcx
movsd  -0x78(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm3
mov    -0x2c(%rbp),%r8d
mov    -0x30(%rbp),%r9d
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%edx
mov    %edx,-0xc0(%rbp)
mov    -0x40(%rbp),%edx
mov    %edx,-0xbc(%rbp)
mov    -0x48(%rbp),%rdx
mov    %rdx,-0xb8(%rbp)
mov    0x10(%rbp),%rdx
mov    %rdx,-0xb0(%rbp)
mov    0x20(%rbp),%r13
mov    0x28(%rbp),%r12
mov    0x30(%rbp),%r15
mov    0x38(%rbp),%r14
mov    0x40(%rbp),%rbx
mov    0x48(%rbp),%r11
mov    0x50(%rbp),%r10
mov    0x58(%rbp),%rdx
mov    %rdx,-0xa8(%rbp)
movsd  0xbd8(%rip),%xmm0
movsd  0xbe0(%rip),%xmm1
mov    $0xc,%edx
mov    %rax,(%rsp)
mov    -0xc0(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0xbc(%rbp),%eax
mov    %eax,0x10(%rsp)
mov    -0xb8(%rbp),%rax
mov    %rax,0x18(%rsp)
mov    -0xb0(%rbp),%rax
mov    %rax,0x20(%rsp)
mov    -0xa8(%rbp),%rax
mov    %r13,0x28(%rsp)
mov    %r12,0x30(%rsp)
mov    %r15,0x38(%rsp)
mov    %r14,0x40(%rsp)
mov    %rbx,0x48(%rsp)
mov    %r11,0x50(%rsp)
mov    %r10,0x58(%rsp)
mov    %rax,0x60(%rsp)
call   1030 <findNURBSbasisFunIso4xScCP@plt>
movsd  -0x70(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xafd(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0xae8(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xaaa(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0xa95(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0xa8d(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0xa79(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0xa36(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0xa21(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    0x20(%rbp),%rax
mov    -0x4c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
add    $0x1,%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x9dd(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x9c8(%rip),%xmm3
mulsd  %xmm3,%xmm2
addsd  %xmm1,%xmm2
movsd  0x9c0(%rip),%xmm1
mulsd  %xmm2,%xmm1
movsd  0x9ac(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x4c(%rbp),%edi
mov    -0x50(%rbp),%esi
lea    -0x70(%rbp),%rcx
movsd  -0x78(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm3
mov    -0x2c(%rbp),%r8d
mov    -0x30(%rbp),%r9d
mov    -0x38(%rbp),%rax
mov    -0x3c(%rbp),%edx
mov    %edx,-0xa0(%rbp)
mov    -0x40(%rbp),%edx
mov    %edx,-0x9c(%rbp)
mov    -0x48(%rbp),%rdx
mov    %rdx,-0x98(%rbp)
mov    0x10(%rbp),%rdx
mov    %rdx,-0x90(%rbp)
mov    0x20(%rbp),%r13
mov    0x28(%rbp),%r12
mov    0x30(%rbp),%r15
mov    0x38(%rbp),%r14
mov    0x40(%rbp),%rbx
mov    0x48(%rbp),%r11
mov    0x50(%rbp),%r10
mov    0x58(%rbp),%rdx
mov    %rdx,-0x88(%rbp)
movsd  0x928(%rip),%xmm1
mov    $0xc,%edx
movaps %xmm1,%xmm0
mov    %rax,(%rsp)
mov    -0xa0(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0x9c(%rbp),%eax
mov    %eax,0x10(%rsp)
mov    -0x98(%rbp),%rax
mov    %rax,0x18(%rsp)
mov    -0x90(%rbp),%rax
mov    %rax,0x20(%rsp)
mov    -0x88(%rbp),%rax
mov    %r13,0x28(%rsp)
mov    %r12,0x30(%rsp)
mov    %r15,0x38(%rsp)
mov    %r14,0x40(%rsp)
mov    %rbx,0x48(%rsp)
mov    %r11,0x50(%rsp)
mov    %r10,0x58(%rsp)
mov    %rax,0x60(%rsp)
call   1030 <findNURBSbasisFunIso4xScCP@plt>
movsd  -0x70(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
movsd  -0x68(%rbp),%xmm0
mov    0x18(%rbp),%rax
mov    -0x54(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x54(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x54(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    11cc <NURBSsurfaceBasisX4ScMax+0xbc>
jmp    2799 <NURBSsurfaceBasisX4ScMax+0x1689>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1181 <NURBSsurfaceBasisX4ScMax+0x71>
add    $0x1c8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<NURBSsurfaceBasisX4ScMax>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
cmp    $0x2,%r8d
jge    1139 <NURBSsurfaceBasisX4ScMax+0x29>
add    $0x118,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    %r9,%r14
mov    %rdx,%r9
mov    0x160(%rsp),%r13
lea    0x1(%rsi),%ebp
movslq %edi,%rbx
lea    -0x1(%rcx),%eax
movslq %ebp,%rbp
mov    %rbp,0xd8(%rsp)
lea    -0x1(%r8),%ebp
mov    %rbp,0xd0(%rsp)
lea    (%rcx,%rcx,1),%edx
shl    $0x4,%rax
lea    (%r14,%rbx,8),%rbp
add    $0x10,%rbp
mov    %rbp,0xe8(%rsp)
movsd  0xe7a(%rip),%xmm0
movapd 0xea2(%rip),%xmm5
movsd  0xe72(%rip),%xmm3
xor    %r12d,%r12d
mov    %rdx,0xc8(%rsp)
mov    %rdx,0xa8(%rsp)
xor    %edx,%edx
xor    %r10d,%r10d
mov    %r14,0x30(%rsp)
mov    %rax,0xf0(%rsp)
mov    %edi,0x2c(%rsp)
mov    %rsi,0x60(%rsp)
mov    %r8,0x80(%rsp)
mov    %rcx,0x40(%rsp)
mov    %r9,0x48(%rsp)
jmp    1221 <NURBSsurfaceBasisX4ScMax+0x111>
nopl   0x0(%rax,%rax,1)
mov    0xc0(%rsp),%r12
mov    0xa8(%rsp),%rdx
mov    0xc8(%rsp),%rcx
add    %rcx,%r12
add    %rcx,%rdx
mov    %rdx,0xa8(%rsp)
mov    0xe0(%rsp),%rdx
cmp    0xd0(%rsp),%rdx
mov    0x40(%rsp),%rcx
je     1127 <NURBSsurfaceBasisX4ScMax+0x17>
mov    %r12,0xc0(%rsp)
lea    0x1(%rdx),%rax
mov    %rax,0xe0(%rsp)
mov    0xd8(%rsp),%rax
add    %rdx,%rax
add    $0x1,%rax
mov    0x150(%rsp),%rbp
movsd  0x0(%rbp,%rax,8),%xmm7
subsd  0x0(%rbp,%rdx,8),%xmm7
mulsd  %xmm0,%xmm7
cmp    $0x2,%ecx
jl     11e0 <NURBSsurfaceBasisX4ScMax+0xd0>
lea    (%r10,%r10,1),%ebp
mov    %rbp,0xf8(%rsp)
xor    %ebx,%ebx
xor    %esi,%esi
xor    %ebp,%ebp
mov    0xc0(%rsp),%r12
mov    %rdx,0x50(%rsp)
mov    0xa8(%rsp),%rdx
movsd  %xmm7,0x38(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    %esi,0xc(%rsp)
mov    %r10,0x100(%rsp)
mov    %rbp,0x108(%rsp)
mov    %rbx,0x110(%rsp)
mov    0xe8(%rsp),%rax
movsd  (%rax,%rbx,4),%xmm1
subsd  (%r14,%rbx,4),%xmm1
mulsd  %xmm0,%xmm1
movapd %xmm1,%xmm2
movsd  %xmm1,0x58(%rsp)
lea    (%r12,%rbx,1),%rax
movslq %eax,%r12
lea    0x2(%r12),%eax
movslq %eax,%rsi
mov    %rsi,0x98(%rsp)
lea    (%rdx,%rbx,1),%rax
movslq %eax,%rbx
lea    0x2(%rbx),%eax
movslq %eax,%rdx
mov    %rdx,0xb8(%rsp)
lea    0x1(%r12),%eax
lea    0x3(%r12),%ecx
movslq %ecx,%rcx
mov    %rcx,0x78(%rsp)
movsd  0x0(%r13,%rsi,8),%xmm0
movhpd 0x0(%r13,%rcx,8),%xmm0
movslq %eax,%r15
movsd  0x0(%r13,%r12,8),%xmm1
movhpd 0x0(%r13,%r15,8),%xmm1
mov    %r15,0xb0(%rsp)
movapd 0xcd6(%rip),%xmm6
mulpd  %xmm6,%xmm0
mulpd  %xmm5,%xmm1
addpd  %xmm0,%xmm1
mov    %rbx,0x68(%rsp)
lea    0x1(%rbx),%eax
movslq %eax,%rcx
mov    %rcx,0x70(%rsp)
lea    0x3(%rbx),%eax
cltq
mov    %rax,0x90(%rsp)
movsd  0x0(%r13,%rdx,8),%xmm0
movhpd 0x0(%r13,%rax,8),%xmm0
mulpd  %xmm6,%xmm0
movsd  0x0(%r13,%rbx,8),%xmm4
movhpd 0x0(%r13,%rcx,8),%xmm4
mulpd  0xc95(%rip),%xmm4
addpd  %xmm0,%xmm4
mulpd  %xmm6,%xmm4
mulpd  0xc85(%rip),%xmm1
addpd  %xmm4,%xmm1
movapd %xmm1,0x10(%rsp)
sub    $0x8,%rsp
mov    0x58(%rsp),%rdi
mov    0x14(%rsp),%esi
movaps %xmm3,%xmm0
movaps %xmm3,%xmm1
mov    $0xc,%edx
lea    0x18(%rsp),%rcx
movapd %xmm7,%xmm3
mov    0x34(%rsp),%r8d
mov    0x68(%rsp),%r9
mov    0x1a0(%rsp),%rax
push   %rax
mov    0x1a0(%rsp),%r14
push   %r14
mov    0x1a0(%rsp),%rax
push   %rax
mov    0x1a0(%rsp),%rax
push   %rax
mov    0x1a0(%rsp),%rax
push   %rax
mov    0x1a0(%rsp),%rax
push   %rax
mov    0x1a0(%rsp),%rax
push   %rax
push   %r13
mov    0x198(%rsp),%rax
push   %rax
push   0x80(%rsp)
mov    0xd8(%rsp),%rax
push   %rax
mov    %rax,%r14
push   0xa0(%rsp)
push   0xb0(%rsp)
call   1030 <findNURBSbasisFunIso4xScCP@plt>
add    $0x70,%rsp
movsd  0x10(%rsp),%xmm0
mov    0xf8(%rsp),%rax
add    %rbp,%rax
movslq %eax,%rdx
mov    %rdx,0x88(%rsp)
mov    0x158(%rsp),%rcx
movsd  %xmm0,(%rcx,%rdx,8)
movsd  0x18(%rsp),%xmm0
lea    0x1(%rdx),%eax
cltq
movsd  %xmm0,(%rcx,%rax,8)
mov    0x98(%rsp),%rbp
movsd  0x0(%r13,%rbp,8),%xmm0
mov    0x78(%rsp),%rbx
movhpd 0x0(%r13,%rbx,8),%xmm0
mov    %r12,0xa0(%rsp)
movsd  0x0(%r13,%r12,8),%xmm1
movhpd 0x0(%r13,%r15,8),%xmm1
movapd 0xb79(%rip),%xmm3
mulpd  %xmm3,%xmm0
mulpd  %xmm3,%xmm1
addpd  %xmm0,%xmm1
mov    0xb8(%rsp),%r15
movsd  0x0(%r13,%r15,8),%xmm0
mov    0x90(%rsp),%rax
movhpd 0x0(%r13,%rax,8),%xmm0
mulpd  %xmm3,%xmm0
mov    0x68(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm2
mov    0x70(%rsp),%rax
movhpd 0x0(%r13,%rax,8),%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm0,%xmm2
mulpd  0xb03(%rip),%xmm2
mulpd  0xb0b(%rip),%xmm1
addpd  %xmm2,%xmm1
movapd %xmm1,0x10(%rsp)
sub    $0x8,%rsp
mov    0x58(%rsp),%rdi
mov    0x14(%rsp),%esi
movsd  0xac4(%rip),%xmm0
movsd  0xac4(%rip),%xmm1
mov    $0xc,%edx
lea    0x18(%rsp),%rcx
movsd  0x60(%rsp),%xmm2
movsd  0x40(%rsp),%xmm3
mov    0x34(%rsp),%r8d
mov    0x68(%rsp),%r9
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   %r13
push   0x198(%rsp)
push   0x80(%rsp)
push   %r14
push   0xa0(%rsp)
push   0xb0(%rsp)
call   1030 <findNURBSbasisFunIso4xScCP@plt>
add    $0x70,%rsp
movsd  0x10(%rsp),%xmm0
mov    0x88(%rsp),%rdx
lea    0x2(%rdx),%eax
cltq
mov    0x158(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
movsd  0x18(%rsp),%xmm0
lea    0x3(%rdx),%eax
cltq
movsd  %xmm0,(%rcx,%rax,8)
movsd  0x0(%r13,%rbp,8),%xmm0
movhpd 0x0(%r13,%rbx,8),%xmm0
movsd  0x0(%r13,%r12,8),%xmm1
mov    0xb0(%rsp),%r14
movhpd 0x0(%r13,%r14,8),%xmm1
mulpd  0xa0e(%rip),%xmm0
movapd 0x9f6(%rip),%xmm3
mulpd  %xmm3,%xmm1
addpd  %xmm0,%xmm1
movsd  0x0(%r13,%r15,8),%xmm0
mov    0x90(%rsp),%rbx
movhpd 0x0(%r13,%rbx,8),%xmm0
mulpd  0x9e0(%rip),%xmm0
mov    0x68(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm2
mov    0x70(%rsp),%rax
movhpd 0x0(%r13,%rax,8),%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm0,%xmm2
mulpd  %xmm3,%xmm2
mulpd  0x9b4(%rip),%xmm1
addpd  %xmm2,%xmm1
movapd %xmm1,0x10(%rsp)
sub    $0x8,%rsp
mov    0x58(%rsp),%rdi
mov    0x14(%rsp),%esi
movsd  0x96d(%rip),%xmm0
movsd  0x975(%rip),%xmm1
mov    $0xc,%edx
lea    0x18(%rsp),%rcx
movsd  0x60(%rsp),%xmm2
movsd  0x40(%rsp),%xmm3
mov    0x34(%rsp),%r8d
mov    0x68(%rsp),%rbp
mov    %ebp,%r9d
push   0x1a0(%rsp)
push   0x1a0(%rsp)
mov    0x1a0(%rsp),%rax
push   %rax
push   0x1a0(%rsp)
mov    0x1a0(%rsp),%rax
push   %rax
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   %r13
push   0x198(%rsp)
push   0x80(%rsp)
push   0xd8(%rsp)
push   0xa0(%rsp)
push   0xb0(%rsp)
call   1030 <findNURBSbasisFunIso4xScCP@plt>
add    $0x70,%rsp
movsd  0x10(%rsp),%xmm0
mov    0x88(%rsp),%rdx
lea    0x4(%rdx),%eax
cltq
mov    0x158(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
movsd  0x18(%rsp),%xmm0
lea    0x5(%rdx),%eax
cltq
movsd  %xmm0,(%rcx,%rax,8)
mov    0x98(%rsp),%r12
movsd  0x0(%r13,%r12,8),%xmm0
mov    0x78(%rsp),%rax
movhpd 0x0(%r13,%rax,8),%xmm0
mov    0xa0(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm1
movhpd 0x0(%r13,%r14,8),%xmm1
movapd 0x88e(%rip),%xmm2
mulpd  %xmm2,%xmm0
mulpd  0x892(%rip),%xmm1
addpd  %xmm0,%xmm1
movsd  0x0(%r13,%r15,8),%xmm0
movhpd 0x0(%r13,%rbx,8),%xmm0
mulpd  %xmm2,%xmm0
mov    0x68(%rsp),%r14
movsd  0x0(%r13,%r14,8),%xmm2
mov    0x70(%rsp),%rbx
movhpd 0x0(%r13,%rbx,8),%xmm2
mulpd  0x85c(%rip),%xmm2
addpd  %xmm0,%xmm2
movapd 0x860(%rip),%xmm0
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm1
addpd  %xmm2,%xmm1
movapd %xmm1,0x10(%rsp)
sub    $0x8,%rsp
mov    0x58(%rsp),%rdi
mov    0x14(%rsp),%esi
movsd  0x809(%rip),%xmm0
movsd  0x7f9(%rip),%xmm1
mov    $0xc,%edx
lea    0x18(%rsp),%rcx
movsd  0x60(%rsp),%xmm2
movsd  0x40(%rsp),%xmm3
mov    0x34(%rsp),%r8d
mov    %ebp,%r9d
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   %r13
push   0x198(%rsp)
push   0x80(%rsp)
push   0xd8(%rsp)
mov    0xa0(%rsp),%rbp
push   %rbp
push   0xb0(%rsp)
call   1030 <findNURBSbasisFunIso4xScCP@plt>
add    $0x70,%rsp
movsd  0x10(%rsp),%xmm0
mov    0x88(%rsp),%rdx
lea    0x6(%rdx),%eax
cltq
mov    0x158(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
movsd  0x18(%rsp),%xmm0
lea    0x7(%rdx),%eax
cltq
movsd  %xmm0,(%rcx,%rax,8)
movsd  0x0(%r13,%r12,8),%xmm0
mov    0x78(%rsp),%rax
movhpd 0x0(%r13,%rax,8),%xmm0
mov    0xa0(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm1
mov    0xb0(%rsp),%rax
movhpd 0x0(%r13,%rax,8),%xmm1
mulpd  0x739(%rip),%xmm0
movapd 0x721(%rip),%xmm3
mulpd  %xmm3,%xmm1
addpd  %xmm0,%xmm1
movsd  0x0(%r13,%r15,8),%xmm0
mov    0x90(%rsp),%rax
movhpd 0x0(%r13,%rax,8),%xmm0
mulpd  0x70b(%rip),%xmm0
movsd  0x0(%r13,%r14,8),%xmm2
movhpd 0x0(%r13,%rbx,8),%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm0,%xmm2
movapd 0x6fd(%rip),%xmm0
mulpd  %xmm0,%xmm2
mulpd  %xmm0,%xmm1
addpd  %xmm2,%xmm1
movapd %xmm1,0x10(%rsp)
sub    $0x8,%rsp
mov    0x58(%rsp),%r14
mov    %r14d,%edi
mov    0x14(%rsp),%esi
movsd  0x6a3(%rip),%xmm0
movsd  0x6a3(%rip),%xmm1
mov    $0xc,%edx
lea    0x18(%rsp),%rcx
movsd  0x60(%rsp),%xmm2
movsd  0x40(%rsp),%xmm3
mov    0x34(%rsp),%r12d
mov    %r12d,%r8d
mov    0x68(%rsp),%r9
mov    0x1a0(%rsp),%rax
push   %rax
mov    0x1a0(%rsp),%rax
push   %rax
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   %r13
push   0x198(%rsp)
push   0x80(%rsp)
mov    0xd8(%rsp),%r15
push   %r15
push   %rbp
mov    0xb0(%rsp),%rbp
push   %rbp
call   1030 <findNURBSbasisFunIso4xScCP@plt>
add    $0x70,%rsp
movsd  0x10(%rsp),%xmm0
mov    0x88(%rsp),%rdx
lea    0x8(%rdx),%eax
cltq
mov    0x158(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
movsd  0x18(%rsp),%xmm0
lea    0x9(%rdx),%eax
cltq
movsd  %xmm0,(%rcx,%rax,8)
mov    0x98(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm0
mov    0x78(%rsp),%rax
movhpd 0x0(%r13,%rax,8),%xmm0
mov    0xa0(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm1
mov    0xb0(%rsp),%rbx
movhpd 0x0(%r13,%rbx,8),%xmm1
movapd 0x5b5(%rip),%xmm2
mulpd  %xmm2,%xmm0
mulpd  0x5b9(%rip),%xmm1
addpd  %xmm0,%xmm1
mov    0xb8(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm0
mov    0x90(%rsp),%rax
movhpd 0x0(%r13,%rax,8),%xmm0
mulpd  %xmm2,%xmm0
movapd %xmm2,%xmm3
mov    0x68(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm2
mov    0x70(%rsp),%rax
movhpd 0x0(%r13,%rax,8),%xmm2
mulpd  0x56f(%rip),%xmm2
addpd  %xmm0,%xmm2
mulpd  0x563(%rip),%xmm2
mulpd  %xmm3,%xmm1
addpd  %xmm2,%xmm1
movapd %xmm1,0x10(%rsp)
sub    $0x8,%rsp
mov    %r14d,%edi
mov    0x14(%rsp),%esi
movsd  0x52a(%rip),%xmm0
movsd  0x512(%rip),%xmm1
mov    $0xc,%edx
lea    0x18(%rsp),%rcx
movsd  0x60(%rsp),%xmm2
movsd  0x40(%rsp),%xmm3
mov    %r12d,%r8d
mov    0x68(%rsp),%r12
mov    %r12d,%r9d
push   0x1a0(%rsp)
push   0x1a0(%rsp)
mov    0x1a0(%rsp),%rax
push   %rax
mov    0x1a0(%rsp),%rax
push   %rax
mov    0x1a0(%rsp),%rax
push   %rax
mov    0x1a0(%rsp),%rax
push   %rax
mov    0x1a0(%rsp),%rax
push   %rax
push   %r13
mov    0x198(%rsp),%rax
push   %rax
push   0x80(%rsp)
push   %r15
mov    0xa0(%rsp),%r14
push   %r14
push   %rbp
call   1030 <findNURBSbasisFunIso4xScCP@plt>
add    $0x70,%rsp
movsd  0x10(%rsp),%xmm0
mov    0x88(%rsp),%r15
lea    0xa(%r15),%eax
cltq
mov    0x158(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
movsd  0x18(%rsp),%xmm0
lea    0xb(%r15),%eax
cltq
movsd  %xmm0,(%rcx,%rax,8)
mov    0x98(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm0
mov    0x78(%rsp),%rax
movhpd 0x0(%r13,%rax,8),%xmm0
mov    0xa0(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm1
movhpd 0x0(%r13,%rbx,8),%xmm1
movapd 0x45b(%rip),%xmm2
mulpd  %xmm2,%xmm0
mulpd  %xmm2,%xmm1
addpd  %xmm0,%xmm1
mov    0xb8(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm0
mov    0x90(%rsp),%rbp
movhpd 0x0(%r13,%rbp,8),%xmm0
mulpd  %xmm2,%xmm0
movapd %xmm2,%xmm3
mov    0x68(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm2
mov    0x70(%rsp),%rax
movhpd 0x0(%r13,%rax,8),%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm0,%xmm2
mulpd  0x3f1(%rip),%xmm2
mulpd  0x3d9(%rip),%xmm1
addpd  %xmm2,%xmm1
movapd %xmm1,0x10(%rsp)
sub    $0x8,%rsp
mov    0x58(%rsp),%rdi
mov    0x14(%rsp),%esi
movsd  0x3b2(%rip),%xmm0
movsd  0x3a2(%rip),%xmm1
mov    $0xc,%edx
lea    0x18(%rsp),%rcx
movsd  0x60(%rsp),%xmm2
movsd  0x40(%rsp),%xmm3
mov    0x34(%rsp),%r8d
mov    %r12d,%r9d
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   %r13
push   0x198(%rsp)
push   0x80(%rsp)
mov    0xd8(%rsp),%rbx
push   %rbx
push   %r14
push   0xb0(%rsp)
call   1030 <findNURBSbasisFunIso4xScCP@plt>
add    $0x70,%rsp
movsd  0x10(%rsp),%xmm0
lea    0xc(%r15),%eax
cltq
mov    0x158(%rsp),%rcx
movsd  %xmm0,(%rcx,%rax,8)
movsd  0x18(%rsp),%xmm0
lea    0xd(%r15),%eax
cltq
movsd  %xmm0,(%rcx,%rax,8)
mov    0x98(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm0
mov    0x78(%rsp),%rax
movhpd 0x0(%r13,%rax,8),%xmm0
mov    0xa0(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm1
mov    0x30(%rsp),%r14
mov    0xb0(%rsp),%rax
movhpd 0x0(%r13,%rax,8),%xmm1
mulpd  0x2d8(%rip),%xmm0
movapd 0x2c0(%rip),%xmm3
mulpd  %xmm3,%xmm1
addpd  %xmm0,%xmm1
mov    0xb8(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm0
movhpd 0x0(%r13,%rbp,8),%xmm0
mulpd  0x2aa(%rip),%xmm0
mov    0x68(%rsp),%rax
movsd  0x0(%r13,%rax,8),%xmm2
mov    0xc0(%rsp),%r12
mov    0x70(%rsp),%rax
movhpd 0x0(%r13,%rax,8),%xmm2
mulpd  %xmm3,%xmm2
addpd  %xmm0,%xmm2
mulpd  0x27a(%rip),%xmm2
mulpd  %xmm3,%xmm1
addpd  %xmm2,%xmm1
movapd %xmm1,0x10(%rsp)
sub    $0x8,%rsp
mov    0x58(%rsp),%rdi
mov    0x14(%rsp),%esi
movsd  0x23f(%rip),%xmm0
movaps %xmm0,%xmm1
mov    $0xc,%edx
lea    0x18(%rsp),%rcx
movsd  0x60(%rsp),%xmm2
movsd  0x40(%rsp),%xmm3
mov    0x34(%rsp),%r8d
mov    0x68(%rsp),%r9
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   0x1a0(%rsp)
push   %r13
push   0x198(%rsp)
push   %r14
push   %rbx
push   0xa0(%rsp)
push   0xb0(%rsp)
call   1030 <findNURBSbasisFunIso4xScCP@plt>
mov    0x7c(%rsp),%esi
mov    0x170(%rsp),%r10
mov    0x180(%rsp),%rbx
movsd  0xa8(%rsp),%xmm7
mov    0x118(%rsp),%rdx
movsd  0x18f(%rip),%xmm3
movapd 0x1af(%rip),%xmm5
add    $0x70,%rsp
movsd  0x10(%rsp),%xmm0
lea    0xe(%r15),%eax
cltq
mov    0x158(%rsp),%rdi
movsd  %xmm0,(%rdi,%rax,8)
movsd  0x18(%rsp),%xmm0
add    $0xf,%r15d
movslq %r15d,%rax
mov    0x108(%rsp),%rbp
movsd  %xmm0,(%rdi,%rax,8)
movsd  0x140(%rip),%xmm0
mov    0xf0(%rsp),%rax
add    $0x10,%rbp
add    $0x8,%r10d
add    $0x1,%esi
add    $0x2,%rbx
cmp    %rbp,%rax
jne    12a0 <NURBSsurfaceBasisX4ScMax+0x190>
jmp    11f0 <NURBSsurfaceBasisX4ScMax+0xe0>

LLVM IR (-O0):
define void @NURBSsurfaceBasisX4ScMax(i32 %0, i32 %1, double* %2, i32 %3, i32 %4, double* %5, double* %6, double* %7, double* %8, double* %9, double* %10, double* %11, double* %12, double* %13, double* %14, double* %15) {
%17 = alloca i32
%18 = alloca i32
%19 = alloca double*
%20 = alloca i32
%21 = alloca i32
%22 = alloca double*
%23 = alloca double*
%24 = alloca double*
%25 = alloca double*
%26 = alloca double*
%27 = alloca double*
%28 = alloca double*
%29 = alloca double*
%30 = alloca double*
%31 = alloca double*
%32 = alloca double*
%33 = alloca i32
%34 = alloca i32
%35 = alloca i32
%36 = alloca i32
%37 = alloca i32
%38 = alloca [2 x double]
%39 = alloca double
%40 = alloca double
store i32 %0, i32* %17
store i32 %1, i32* %18
store double* %2, double** %19
store i32 %3, i32* %20
store i32 %4, i32* %21
store double* %5, double** %22
store double* %6, double** %23
store double* %7, double** %24
store double* %8, double** %25
store double* %9, double** %26
store double* %10, double** %27
store double* %11, double** %28
store double* %12, double** %29
store double* %13, double** %30
store double* %14, double** %31
store double* %15, double** %32
%41 = load i32, i32* %17
%42 = add nsw i32 %41, 1
store i32 %42, i32* %36
%43 = load i32, i32* %18
%44 = add nsw i32 %43, 1
store i32 %44, i32* %37
store i32 0, i32* %35
store i32 0, i32* %33
br label %45
45: ; preds = %1243, %16
%46 = load i32, i32* %33
%47 = load i32, i32* %21
%48 = sub nsw i32 %47, 2
%49 = icmp sle i32 %46, %48
br i1 %49, label %50, label %1246
50: ; preds = %45
%51 = load double*, double** %23
%52 = load i32, i32* %33
%53 = add nsw i32 %52, 1
%54 = load i32, i32* %37
%55 = add nsw i32 %53, %54
%56 = sext i32 %55 to i64
%57 = getelementptr inbounds double, double* %51, i64 %56
%58 = load double, double* %57
%59 = load double*, double** %23
%60 = load i32, i32* %33
%61 = sext i32 %60 to i64
%62 = getelementptr inbounds double, double* %59, i64 %61
%63 = load double, double* %62
%64 = fsub double %58, %63
%65 = fmul double 1.000000e-01, %64
store double %65, double* %40
store i32 0, i32* %34
br label %66
66: ; preds = %1239, %50
%67 = load i32, i32* %34
%68 = load i32, i32* %20
%69 = sub nsw i32 %68, 2
%70 = icmp sle i32 %67, %69
br i1 %70, label %71, label %1242
71: ; preds = %66
%72 = load double*, double** %22
%73 = load i32, i32* %34
%74 = add nsw i32 %73, 1
%75 = load i32, i32* %36
%76 = add nsw i32 %74, %75
%77 = sext i32 %76 to i64
%78 = getelementptr inbounds double, double* %72, i64 %77
%79 = load double, double* %78
%80 = load double*, double** %22
%81 = load i32, i32* %34
%82 = sext i32 %81 to i64
%83 = getelementptr inbounds double, double* %80, i64 %82
%84 = load double, double* %83
%85 = fsub double %79, %84
%86 = fmul double 1.000000e-01, %85
store double %86, double* %39
%87 = load double*, double** %25
%88 = load i32, i32* %33
%89 = load i32, i32* %20
%90 = mul nsw i32 %88, %89
%91 = load i32, i32* %34
%92 = add nsw i32 %90, %91
%93 = mul nsw i32 2, %92
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds double, double* %87, i64 %94
%96 = load double, double* %95
%97 = load double*, double** %25
%98 = load i32, i32* %33
%99 = load i32, i32* %20
%100 = mul nsw i32 %98, %99
%101 = load i32, i32* %34
%102 = add nsw i32 %100, %101
%103 = add nsw i32 %102, 1
%104 = mul nsw i32 2, %103
%105 = sext i32 %104 to i64
%106 = getelementptr inbounds double, double* %97, i64 %105
%107 = load double, double* %106
%108 = fmul double 2.500000e-01, %107
%109 = call double @llvm.fmuladd.f64(double 7.500000e-01, double %96, double %108)
%110 = load double*, double** %25
%111 = load i32, i32* %33
%112 = add nsw i32 %111, 1
%113 = load i32, i32* %20
%114 = mul nsw i32 %112, %113
%115 = load i32, i32* %34
%116 = add nsw i32 %114, %115
%117 = mul nsw i32 2, %116
%118 = sext i32 %117 to i64
%119 = getelementptr inbounds double, double* %110, i64 %118
%120 = load double, double* %119
%121 = load double*, double** %25
%122 = load i32, i32* %33
%123 = add nsw i32 %122, 1
%124 = load i32, i32* %20
%125 = mul nsw i32 %123, %124
%126 = load i32, i32* %34
%127 = add nsw i32 %125, %126
%128 = add nsw i32 %127, 1
%129 = mul nsw i32 2, %128
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds double, double* %121, i64 %130
%132 = load double, double* %131
%133 = fmul double 2.500000e-01, %132
%134 = call double @llvm.fmuladd.f64(double 7.500000e-01, double %120, double %133)
%135 = fmul double 2.500000e-01, %134
%136 = call double @llvm.fmuladd.f64(double 7.500000e-01, double %109, double %135)
%137 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
store double %136, double* %137
%138 = load double*, double** %25
%139 = load i32, i32* %33
%140 = load i32, i32* %20
%141 = mul nsw i32 %139, %140
%142 = load i32, i32* %34
%143 = add nsw i32 %141, %142
%144 = mul nsw i32 2, %143
%145 = add nsw i32 %144, 1
%146 = sext i32 %145 to i64
%147 = getelementptr inbounds double, double* %138, i64 %146
%148 = load double, double* %147
%149 = load double*, double** %25
%150 = load i32, i32* %33
%151 = load i32, i32* %20
%152 = mul nsw i32 %150, %151
%153 = load i32, i32* %34
%154 = add nsw i32 %152, %153
%155 = add nsw i32 %154, 1
%156 = mul nsw i32 2, %155
%157 = add nsw i32 %156, 1
%158 = sext i32 %157 to i64
%159 = getelementptr inbounds double, double* %149, i64 %158
%160 = load double, double* %159
%161 = fmul double 2.500000e-01, %160
%162 = call double @llvm.fmuladd.f64(double 7.500000e-01, double %148, double %161)
%163 = load double*, double** %25
%164 = load i32, i32* %33
%165 = add nsw i32 %164, 1
%166 = load i32, i32* %20
%167 = mul nsw i32 %165, %166
%168 = load i32, i32* %34
%169 = add nsw i32 %167, %168
%170 = mul nsw i32 2, %169
%171 = add nsw i32 %170, 1
%172 = sext i32 %171 to i64
%173 = getelementptr inbounds double, double* %163, i64 %172
%174 = load double, double* %173
%175 = load double*, double** %25
%176 = load i32, i32* %33
%177 = add nsw i32 %176, 1
%178 = load i32, i32* %20
%179 = mul nsw i32 %177, %178
%180 = load i32, i32* %34
%181 = add nsw i32 %179, %180
%182 = add nsw i32 %181, 1
%183 = mul nsw i32 2, %182
%184 = add nsw i32 %183, 1
%185 = sext i32 %184 to i64
%186 = getelementptr inbounds double, double* %175, i64 %185
%187 = load double, double* %186
%188 = fmul double 2.500000e-01, %187
%189 = call double @llvm.fmuladd.f64(double 7.500000e-01, double %174, double %188)
%190 = fmul double 2.500000e-01, %189
%191 = call double @llvm.fmuladd.f64(double 7.500000e-01, double %162, double %190)
%192 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 1
store double %191, double* %192
%193 = load i32, i32* %33
%194 = load i32, i32* %34
%195 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
%196 = load double, double* %39
%197 = load double, double* %40
%198 = load i32, i32* %17
%199 = load i32, i32* %18
%200 = load double*, double** %19
%201 = load i32, i32* %20
%202 = load i32, i32* %21
%203 = load double*, double** %22
%204 = load double*, double** %23
%205 = load double*, double** %25
%206 = load double*, double** %26
%207 = load double*, double** %27
%208 = load double*, double** %28
%209 = load double*, double** %29
%210 = load double*, double** %30
%211 = load double*, double** %31
%212 = load double*, double** %32
%213 = call i32 @findNURBSbasisFunIso4xScCP(i32 %193, i32 %194, double 7.500000e-01, double 7.500000e-01, i32 12, double* %195, double %196, double %197, i32 %198, i32 %199, double* %200, i32 %201, i32 %202, double* %203, double* %204, double* %205, double* %206, double* %207, double* %208, double* %209, double* %210, double* %211, double* %212)
%214 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
%215 = load double, double* %214
%216 = load double*, double** %24
%217 = load i32, i32* %35
%218 = mul nsw i32 2, %217
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds double, double* %216, i64 %219
store double %215, double* %220
%221 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 1
%222 = load double, double* %221
%223 = load double*, double** %24
%224 = load i32, i32* %35
%225 = mul nsw i32 2, %224
%226 = add nsw i32 %225, 1
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds double, double* %223, i64 %227
store double %222, double* %228
%229 = load i32, i32* %35
%230 = add nsw i32 %229, 1
store i32 %230, i32* %35
%231 = load double*, double** %25
%232 = load i32, i32* %33
%233 = load i32, i32* %20
%234 = mul nsw i32 %232, %233
%235 = load i32, i32* %34
%236 = add nsw i32 %234, %235
%237 = mul nsw i32 2, %236
%238 = sext i32 %237 to i64
%239 = getelementptr inbounds double, double* %231, i64 %238
%240 = load double, double* %239
%241 = load double*, double** %25
%242 = load i32, i32* %33
%243 = load i32, i32* %20
%244 = mul nsw i32 %242, %243
%245 = load i32, i32* %34
%246 = add nsw i32 %244, %245
%247 = add nsw i32 %246, 1
%248 = mul nsw i32 2, %247
%249 = sext i32 %248 to i64
%250 = getelementptr inbounds double, double* %241, i64 %249
%251 = load double, double* %250
%252 = fmul double 5.000000e-01, %251
%253 = call double @llvm.fmuladd.f64(double 5.000000e-01, double %240, double %252)
%254 = load double*, double** %25
%255 = load i32, i32* %33
%256 = add nsw i32 %255, 1
%257 = load i32, i32* %20
%258 = mul nsw i32 %256, %257
%259 = load i32, i32* %34
%260 = add nsw i32 %258, %259
%261 = mul nsw i32 2, %260
%262 = sext i32 %261 to i64
%263 = getelementptr inbounds double, double* %254, i64 %262
%264 = load double, double* %263
%265 = load double*, double** %25
%266 = load i32, i32* %33
%267 = add nsw i32 %266, 1
%268 = load i32, i32* %20
%269 = mul nsw i32 %267, %268
%270 = load i32, i32* %34
%271 = add nsw i32 %269, %270
%272 = add nsw i32 %271, 1
%273 = mul nsw i32 2, %272
%274 = sext i32 %273 to i64
%275 = getelementptr inbounds double, double* %265, i64 %274
%276 = load double, double* %275
%277 = fmul double 5.000000e-01, %276
%278 = call double @llvm.fmuladd.f64(double 5.000000e-01, double %264, double %277)
%279 = fmul double 2.500000e-01, %278
%280 = call double @llvm.fmuladd.f64(double 7.500000e-01, double %253, double %279)
%281 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
store double %280, double* %281
%282 = load double*, double** %25
%283 = load i32, i32* %33
%284 = load i32, i32* %20
%285 = mul nsw i32 %283, %284
%286 = load i32, i32* %34
%287 = add nsw i32 %285, %286
%288 = mul nsw i32 2, %287
%289 = add nsw i32 %288, 1
%290 = sext i32 %289 to i64
%291 = getelementptr inbounds double, double* %282, i64 %290
%292 = load double, double* %291
%293 = load double*, double** %25
%294 = load i32, i32* %33
%295 = load i32, i32* %20
%296 = mul nsw i32 %294, %295
%297 = load i32, i32* %34
%298 = add nsw i32 %296, %297
%299 = add nsw i32 %298, 1
%300 = mul nsw i32 2, %299
%301 = add nsw i32 %300, 1
%302 = sext i32 %301 to i64
%303 = getelementptr inbounds double, double* %293, i64 %302
%304 = load double, double* %303
%305 = fmul double 5.000000e-01, %304
%306 = call double @llvm.fmuladd.f64(double 5.000000e-01, double %292, double %305)
%307 = load double*, double** %25
%308 = load i32, i32* %33
%309 = add nsw i32 %308, 1
%310 = load i32, i32* %20
%311 = mul nsw i32 %309, %310
%312 = load i32, i32* %34
%313 = add nsw i32 %311, %312
%314 = mul nsw i32 2, %313
%315 = add nsw i32 %314, 1
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds double, double* %307, i64 %316
%318 = load double, double* %317
%319 = load double*, double** %25
%320 = load i32, i32* %33
%321 = add nsw i32 %320, 1
%322 = load i32, i32* %20
%323 = mul nsw i32 %321, %322
%324 = load i32, i32* %34
%325 = add nsw i32 %323, %324
%326 = add nsw i32 %325, 1
%327 = mul nsw i32 2, %326
%328 = add nsw i32 %327, 1
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds double, double* %319, i64 %329
%331 = load double, double* %330
%332 = fmul double 5.000000e-01, %331
%333 = call double @llvm.fmuladd.f64(double 5.000000e-01, double %318, double %332)
%334 = fmul double 2.500000e-01, %333
%335 = call double @llvm.fmuladd.f64(double 7.500000e-01, double %306, double %334)
%336 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 1
store double %335, double* %336
%337 = load i32, i32* %33
%338 = load i32, i32* %34
%339 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
%340 = load double, double* %39
%341 = load double, double* %40
%342 = load i32, i32* %17
%343 = load i32, i32* %18
%344 = load double*, double** %19
%345 = load i32, i32* %20
%346 = load i32, i32* %21
%347 = load double*, double** %22
%348 = load double*, double** %23
%349 = load double*, double** %25
%350 = load double*, double** %26
%351 = load double*, double** %27
%352 = load double*, double** %28
%353 = load double*, double** %29
%354 = load double*, double** %30
%355 = load double*, double** %31
%356 = load double*, double** %32
%357 = call i32 @findNURBSbasisFunIso4xScCP(i32 %337, i32 %338, double 7.500000e-01, double 5.000000e-01, i32 12, double* %339, double %340, double %341, i32 %342, i32 %343, double* %344, i32 %345, i32 %346, double* %347, double* %348, double* %349, double* %350, double* %351, double* %352, double* %353, double* %354, double* %355, double* %356)
%358 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
%359 = load double, double* %358
%360 = load double*, double** %24
%361 = load i32, i32* %35
%362 = mul nsw i32 2, %361
%363 = sext i32 %362 to i64
%364 = getelementptr inbounds double, double* %360, i64 %363
store double %359, double* %364
%365 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 1
%366 = load double, double* %365
%367 = load double*, double** %24
%368 = load i32, i32* %35
%369 = mul nsw i32 2, %368
%370 = add nsw i32 %369, 1
%371 = sext i32 %370 to i64
%372 = getelementptr inbounds double, double* %367, i64 %371
store double %366, double* %372
%373 = load i32, i32* %35
%374 = add nsw i32 %373, 1
store i32 %374, i32* %35
%375 = load double*, double** %25
%376 = load i32, i32* %33
%377 = load i32, i32* %20
%378 = mul nsw i32 %376, %377
%379 = load i32, i32* %34
%380 = add nsw i32 %378, %379
%381 = mul nsw i32 2, %380
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds double, double* %375, i64 %382
%384 = load double, double* %383
%385 = load double*, double** %25
%386 = load i32, i32* %33
%387 = load i32, i32* %20
%388 = mul nsw i32 %386, %387
%389 = load i32, i32* %34
%390 = add nsw i32 %388, %389
%391 = add nsw i32 %390, 1
%392 = mul nsw i32 2, %391
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds double, double* %385, i64 %393
%395 = load double, double* %394
%396 = fmul double 7.500000e-01, %395
%397 = call double @llvm.fmuladd.f64(double 2.500000e-01, double %384, double %396)
%398 = load double*, double** %25
%399 = load i32, i32* %33
%400 = add nsw i32 %399, 1
%401 = load i32, i32* %20
%402 = mul nsw i32 %400, %401
%403 = load i32, i32* %34
%404 = add nsw i32 %402, %403
%405 = mul nsw i32 2, %404
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds double, double* %398, i64 %406
%408 = load double, double* %407
%409 = load double*, double** %25
%410 = load i32, i32* %33
%411 = add nsw i32 %410, 1
%412 = load i32, i32* %20
%413 = mul nsw i32 %411, %412
%414 = load i32, i32* %34
%415 = add nsw i32 %413, %414
%416 = add nsw i32 %415, 1
%417 = mul nsw i32 2, %416
%418 = sext i32 %417 to i64
%419 = getelementptr inbounds double, double* %409, i64 %418
%420 = load double, double* %419
%421 = fmul double 7.500000e-01, %420
%422 = call double @llvm.fmuladd.f64(double 2.500000e-01, double %408, double %421)
%423 = fmul double 2.500000e-01, %422
%424 = call double @llvm.fmuladd.f64(double 7.500000e-01, double %397, double %423)
%425 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
store double %424, double* %425
%426 = load double*, double** %25
%427 = load i32, i32* %33
%428 = load i32, i32* %20
%429 = mul nsw i32 %427, %428
%430 = load i32, i32* %34
%431 = add nsw i32 %429, %430
%432 = mul nsw i32 2, %431
%433 = add nsw i32 %432, 1
%434 = sext i32 %433 to i64
%435 = getelementptr inbounds double, double* %426, i64 %434
%436 = load double, double* %435
%437 = load double*, double** %25
%438 = load i32, i32* %33
%439 = load i32, i32* %20
%440 = mul nsw i32 %438, %439
%441 = load i32, i32* %34
%442 = add nsw i32 %440, %441
%443 = add nsw i32 %442, 1
%444 = mul nsw i32 2, %443
%445 = add nsw i32 %444, 1
%446 = sext i32 %445 to i64
%447 = getelementptr inbounds double, double* %437, i64 %446
%448 = load double, double* %447
%449 = fmul double 7.500000e-01, %448
%450 = call double @llvm.fmuladd.f64(double 2.500000e-01, double %436, double %449)
%451 = load double*, double** %25
%452 = load i32, i32* %33
%453 = add nsw i32 %452, 1
%454 = load i32, i32* %20
%455 = mul nsw i32 %453, %454
%456 = load i32, i32* %34
%457 = add nsw i32 %455, %456
%458 = mul nsw i32 2, %457
%459 = add nsw i32 %458, 1
%460 = sext i32 %459 to i64
%461 = getelementptr inbounds double, double* %451, i64 %460
%462 = load double, double* %461
%463 = load double*, double** %25
%464 = load i32, i32* %33
%465 = add nsw i32 %464, 1
%466 = load i32, i32* %20
%467 = mul nsw i32 %465, %466
%468 = load i32, i32* %34
%469 = add nsw i32 %467, %468
%470 = add nsw i32 %469, 1
%471 = mul nsw i32 2, %470
%472 = add nsw i32 %471, 1
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds double, double* %463, i64 %473
%475 = load double, double* %474
%476 = fmul double 7.500000e-01, %475
%477 = call double @llvm.fmuladd.f64(double 2.500000e-01, double %462, double %476)
%478 = fmul double 2.500000e-01, %477
%479 = call double @llvm.fmuladd.f64(double 7.500000e-01, double %450, double %478)
%480 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 1
store double %479, double* %480
%481 = load i32, i32* %33
%482 = load i32, i32* %34
%483 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
%484 = load double, double* %39
%485 = load double, double* %40
%486 = load i32, i32* %17
%487 = load i32, i32* %18
%488 = load double*, double** %19
%489 = load i32, i32* %20
%490 = load i32, i32* %21
%491 = load double*, double** %22
%492 = load double*, double** %23
%493 = load double*, double** %25
%494 = load double*, double** %26
%495 = load double*, double** %27
%496 = load double*, double** %28
%497 = load double*, double** %29
%498 = load double*, double** %30
%499 = load double*, double** %31
%500 = load double*, double** %32
%501 = call i32 @findNURBSbasisFunIso4xScCP(i32 %481, i32 %482, double 7.500000e-01, double 2.500000e-01, i32 12, double* %483, double %484, double %485, i32 %486, i32 %487, double* %488, i32 %489, i32 %490, double* %491, double* %492, double* %493, double* %494, double* %495, double* %496, double* %497, double* %498, double* %499, double* %500)
%502 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
%503 = load double, double* %502
%504 = load double*, double** %24
%505 = load i32, i32* %35
%506 = mul nsw i32 2, %505
%507 = sext i32 %506 to i64
%508 = getelementptr inbounds double, double* %504, i64 %507
store double %503, double* %508
%509 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 1
%510 = load double, double* %509
%511 = load double*, double** %24
%512 = load i32, i32* %35
%513 = mul nsw i32 2, %512
%514 = add nsw i32 %513, 1
%515 = sext i32 %514 to i64
%516 = getelementptr inbounds double, double* %511, i64 %515
store double %510, double* %516
%517 = load i32, i32* %35
%518 = add nsw i32 %517, 1
store i32 %518, i32* %35
%519 = load double*, double** %25
%520 = load i32, i32* %33
%521 = load i32, i32* %20
%522 = mul nsw i32 %520, %521
%523 = load i32, i32* %34
%524 = add nsw i32 %522, %523
%525 = mul nsw i32 2, %524
%526 = sext i32 %525 to i64
%527 = getelementptr inbounds double, double* %519, i64 %526
%528 = load double, double* %527
%529 = load double*, double** %25
%530 = load i32, i32* %33
%531 = load i32, i32* %20
%532 = mul nsw i32 %530, %531
%533 = load i32, i32* %34
%534 = add nsw i32 %532, %533
%535 = add nsw i32 %534, 1
%536 = mul nsw i32 2, %535
%537 = sext i32 %536 to i64
%538 = getelementptr inbounds double, double* %529, i64 %537
%539 = load double, double* %538
%540 = fmul double 2.500000e-01, %539
%541 = call double @llvm.fmuladd.f64(double 7.500000e-01, double %528, double %540)
%542 = load double*, double** %25
%543 = load i32, i32* %33
%544 = add nsw i32 %543, 1
%545 = load i32, i32* %20
%546 = mul nsw i32 %544, %545
%547 = load i32, i32* %34
%548 = add nsw i32 %546, %547
%549 = mul nsw i32 2, %548
%550 = sext i32 %549 to i64
%551 = getelementptr inbounds double, double* %542, i64 %550
%552 = load double, double* %551
%553 = load double*, double** %25
%554 = load i32, i32* %33
%555 = add nsw i32 %554, 1
%556 = load i32, i32* %20
%557 = mul nsw i32 %555, %556
%558 = load i32, i32* %34
%559 = add nsw i32 %557, %558
%560 = add nsw i32 %559, 1
%561 = mul nsw i32 2, %560
%562 = sext i32 %561 to i64
%563 = getelementptr inbounds double, double* %553, i64 %562
%564 = load double, double* %563
%565 = fmul double 2.500000e-01, %564
%566 = call double @llvm.fmuladd.f64(double 7.500000e-01, double %552, double %565)
%567 = fmul double 5.000000e-01, %566
%568 = call double @llvm.fmuladd.f64(double 5.000000e-01, double %541, double %567)
%569 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
store double %568, double* %569
%570 = load double*, double** %25
%571 = load i32, i32* %33
%572 = load i32, i32* %20
%573 = mul nsw i32 %571, %572
%574 = load i32, i32* %34
%575 = add nsw i32 %573, %574
%576 = mul nsw i32 2, %575
%577 = add nsw i32 %576, 1
%578 = sext i32 %577 to i64
%579 = getelementptr inbounds double, double* %570, i64 %578
%580 = load double, double* %579
%581 = load double*, double** %25
%582 = load i32, i32* %33
%583 = load i32, i32* %20
%584 = mul nsw i32 %582, %583
%585 = load i32, i32* %34
%586 = add nsw i32 %584, %585
%587 = add nsw i32 %586, 1
%588 = mul nsw i32 2, %587
%589 = add nsw i32 %588, 1
%590 = sext i32 %589 to i64
%591 = getelementptr inbounds double, double* %581, i64 %590
%592 = load double, double* %591
%593 = fmul double 2.500000e-01, %592
%594 = call double @llvm.fmuladd.f64(double 7.500000e-01, double %580, double %593)
%595 = load double*, double** %25
%596 = load i32, i32* %33
%597 = add nsw i32 %596, 1
%598 = load i32, i32* %20
%599 = mul nsw i32 %597, %598
%600 = load i32, i32* %34
%601 = add nsw i32 %599, %600
%602 = mul nsw i32 2, %601
%603 = add nsw i32 %602, 1
%604 = sext i32 %603 to i64
%605 = getelementptr inbounds double, double* %595, i64 %604
%606 = load double, double* %605
%607 = load double*, double** %25
%608 = load i32, i32* %33
%609 = add nsw i32 %608, 1
%610 = load i32, i32* %20
%611 = mul nsw i32 %609, %610
%612 = load i32, i32* %34
%613 = add nsw i32 %611, %612
%614 = add nsw i32 %613, 1
%615 = mul nsw i32 2, %614
%616 = add nsw i32 %615, 1
%617 = sext i32 %616 to i64
%618 = getelementptr inbounds double, double* %607, i64 %617
%619 = load double, double* %618
%620 = fmul double 2.500000e-01, %619
%621 = call double @llvm.fmuladd.f64(double 7.500000e-01, double %606, double %620)
%622 = fmul double 5.000000e-01, %621
%623 = call double @llvm.fmuladd.f64(double 5.000000e-01, double %594, double %622)
%624 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 1
store double %623, double* %624
%625 = load i32, i32* %33
%626 = load i32, i32* %34
%627 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
%628 = load double, double* %39
%629 = load double, double* %40
%630 = load i32, i32* %17
%631 = load i32, i32* %18
%632 = load double*, double** %19
%633 = load i32, i32* %20
%634 = load i32, i32* %21
%635 = load double*, double** %22
%636 = load double*, double** %23
%637 = load double*, double** %25
%638 = load double*, double** %26
%639 = load double*, double** %27
%640 = load double*, double** %28
%641 = load double*, double** %29
%642 = load double*, double** %30
%643 = load double*, double** %31
%644 = load double*, double** %32
%645 = call i32 @findNURBSbasisFunIso4xScCP(i32 %625, i32 %626, double 5.000000e-01, double 7.500000e-01, i32 12, double* %627, double %628, double %629, i32 %630, i32 %631, double* %632, i32 %633, i32 %634, double* %635, double* %636, double* %637, double* %638, double* %639, double* %640, double* %641, double* %642, double* %643, double* %644)
%646 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
%647 = load double, double* %646
%648 = load double*, double** %24
%649 = load i32, i32* %35
%650 = mul nsw i32 2, %649
%651 = sext i32 %650 to i64
%652 = getelementptr inbounds double, double* %648, i64 %651
store double %647, double* %652
%653 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 1
%654 = load double, double* %653
%655 = load double*, double** %24
%656 = load i32, i32* %35
%657 = mul nsw i32 2, %656
%658 = add nsw i32 %657, 1
%659 = sext i32 %658 to i64
%660 = getelementptr inbounds double, double* %655, i64 %659
store double %654, double* %660
%661 = load i32, i32* %35
%662 = add nsw i32 %661, 1
store i32 %662, i32* %35
%663 = load double*, double** %25
%664 = load i32, i32* %33
%665 = load i32, i32* %20
%666 = mul nsw i32 %664, %665
%667 = load i32, i32* %34
%668 = add nsw i32 %666, %667
%669 = mul nsw i32 2, %668
%670 = sext i32 %669 to i64
%671 = getelementptr inbounds double, double* %663, i64 %670
%672 = load double, double* %671
%673 = load double*, double** %25
%674 = load i32, i32* %33
%675 = load i32, i32* %20
%676 = mul nsw i32 %674, %675
%677 = load i32, i32* %34
%678 = add nsw i32 %676, %677
%679 = add nsw i32 %678, 1
%680 = mul nsw i32 2, %679
%681 = sext i32 %680 to i64
%682 = getelementptr inbounds double, double* %673, i64 %681
%683 = load double, double* %682
%684 = fmul double 7.500000e-01, %683
%685 = call double @llvm.fmuladd.f64(double 2.500000e-01, double %672, double %684)
%686 = load double*, double** %25
%687 = load i32, i32* %33
%688 = add nsw i32 %687, 1
%689 = load i32, i32* %20
%690 = mul nsw i32 %688, %689
%691 = load i32, i32* %34
%692 = add nsw i32 %690, %691
%693 = mul nsw i32 2, %692
%694 = sext i32 %693 to i64
%695 = getelementptr inbounds double, double* %686, i64 %694
%696 = load double, double* %695
%697 = load double*, double** %25
%698 = load i32, i32* %33
%699 = add nsw i32 %698, 1
%700 = load i32, i32* %20
%701 = mul nsw i32 %699, %700
%702 = load i32, i32* %34
%703 = add nsw i32 %701, %702
%704 = add nsw i32 %703, 1
%705 = mul nsw i32 2, %704
%706 = sext i32 %705 to i64
%707 = getelementptr inbounds double, double* %697, i64 %706
%708 = load double, double* %707
%709 = fmul double 7.500000e-01, %708
%710 = call double @llvm.fmuladd.f64(double 2.500000e-01, double %696, double %709)
%711 = fmul double 5.000000e-01, %710
%712 = call double @llvm.fmuladd.f64(double 5.000000e-01, double %685, double %711)
%713 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
store double %712, double* %713
%714 = load double*, double** %25
%715 = load i32, i32* %33
%716 = load i32, i32* %20
%717 = mul nsw i32 %715, %716
%718 = load i32, i32* %34
%719 = add nsw i32 %717, %718
%720 = mul nsw i32 2, %719
%721 = add nsw i32 %720, 1
%722 = sext i32 %721 to i64
%723 = getelementptr inbounds double, double* %714, i64 %722
%724 = load double, double* %723
%725 = load double*, double** %25
%726 = load i32, i32* %33
%727 = load i32, i32* %20
%728 = mul nsw i32 %726, %727
%729 = load i32, i32* %34
%730 = add nsw i32 %728, %729
%731 = add nsw i32 %730, 1
%732 = mul nsw i32 2, %731
%733 = add nsw i32 %732, 1
%734 = sext i32 %733 to i64
%735 = getelementptr inbounds double, double* %725, i64 %734
%736 = load double, double* %735
%737 = fmul double 7.500000e-01, %736
%738 = call double @llvm.fmuladd.f64(double 2.500000e-01, double %724, double %737)
%739 = load double*, double** %25
%740 = load i32, i32* %33
%741 = add nsw i32 %740, 1
%742 = load i32, i32* %20
%743 = mul nsw i32 %741, %742
%744 = load i32, i32* %34
%745 = add nsw i32 %743, %744
%746 = mul nsw i32 2, %745
%747 = add nsw i32 %746, 1
%748 = sext i32 %747 to i64
%749 = getelementptr inbounds double, double* %739, i64 %748
%750 = load double, double* %749
%751 = load double*, double** %25
%752 = load i32, i32* %33
%753 = add nsw i32 %752, 1
%754 = load i32, i32* %20
%755 = mul nsw i32 %753, %754
%756 = load i32, i32* %34
%757 = add nsw i32 %755, %756
%758 = add nsw i32 %757, 1
%759 = mul nsw i32 2, %758
%760 = add nsw i32 %759, 1
%761 = sext i32 %760 to i64
%762 = getelementptr inbounds double, double* %751, i64 %761
%763 = load double, double* %762
%764 = fmul double 7.500000e-01, %763
%765 = call double @llvm.fmuladd.f64(double 2.500000e-01, double %750, double %764)
%766 = fmul double 5.000000e-01, %765
%767 = call double @llvm.fmuladd.f64(double 5.000000e-01, double %738, double %766)
%768 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 1
store double %767, double* %768
%769 = load i32, i32* %33
%770 = load i32, i32* %34
%771 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
%772 = load double, double* %39
%773 = load double, double* %40
%774 = load i32, i32* %17
%775 = load i32, i32* %18
%776 = load double*, double** %19
%777 = load i32, i32* %20
%778 = load i32, i32* %21
%779 = load double*, double** %22
%780 = load double*, double** %23
%781 = load double*, double** %25
%782 = load double*, double** %26
%783 = load double*, double** %27
%784 = load double*, double** %28
%785 = load double*, double** %29
%786 = load double*, double** %30
%787 = load double*, double** %31
%788 = load double*, double** %32
%789 = call i32 @findNURBSbasisFunIso4xScCP(i32 %769, i32 %770, double 5.000000e-01, double 2.500000e-01, i32 12, double* %771, double %772, double %773, i32 %774, i32 %775, double* %776, i32 %777, i32 %778, double* %779, double* %780, double* %781, double* %782, double* %783, double* %784, double* %785, double* %786, double* %787, double* %788)
%790 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
%791 = load double, double* %790
%792 = load double*, double** %24
%793 = load i32, i32* %35
%794 = mul nsw i32 2, %793
%795 = sext i32 %794 to i64
%796 = getelementptr inbounds double, double* %792, i64 %795
store double %791, double* %796
%797 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 1
%798 = load double, double* %797
%799 = load double*, double** %24
%800 = load i32, i32* %35
%801 = mul nsw i32 2, %800
%802 = add nsw i32 %801, 1
%803 = sext i32 %802 to i64
%804 = getelementptr inbounds double, double* %799, i64 %803
store double %798, double* %804
%805 = load i32, i32* %35
%806 = add nsw i32 %805, 1
store i32 %806, i32* %35
%807 = load double*, double** %25
%808 = load i32, i32* %33
%809 = load i32, i32* %20
%810 = mul nsw i32 %808, %809
%811 = load i32, i32* %34
%812 = add nsw i32 %810, %811
%813 = mul nsw i32 2, %812
%814 = sext i32 %813 to i64
%815 = getelementptr inbounds double, double* %807, i64 %814
%816 = load double, double* %815
%817 = load double*, double** %25
%818 = load i32, i32* %33
%819 = load i32, i32* %20
%820 = mul nsw i32 %818, %819
%821 = load i32, i32* %34
%822 = add nsw i32 %820, %821
%823 = add nsw i32 %822, 1
%824 = mul nsw i32 2, %823
%825 = sext i32 %824 to i64
%826 = getelementptr inbounds double, double* %817, i64 %825
%827 = load double, double* %826
%828 = fmul double 2.500000e-01, %827
%829 = call double @llvm.fmuladd.f64(double 7.500000e-01, double %816, double %828)
%830 = load double*, double** %25
%831 = load i32, i32* %33
%832 = add nsw i32 %831, 1
%833 = load i32, i32* %20
%834 = mul nsw i32 %832, %833
%835 = load i32, i32* %34
%836 = add nsw i32 %834, %835
%837 = mul nsw i32 2, %836
%838 = sext i32 %837 to i64
%839 = getelementptr inbounds double, double* %830, i64 %838
%840 = load double, double* %839
%841 = load double*, double** %25
%842 = load i32, i32* %33
%843 = add nsw i32 %842, 1
%844 = load i32, i32* %20
%845 = mul nsw i32 %843, %844
%846 = load i32, i32* %34
%847 = add nsw i32 %845, %846
%848 = add nsw i32 %847, 1
%849 = mul nsw i32 2, %848
%850 = sext i32 %849 to i64
%851 = getelementptr inbounds double, double* %841, i64 %850
%852 = load double, double* %851
%853 = fmul double 2.500000e-01, %852
%854 = call double @llvm.fmuladd.f64(double 7.500000e-01, double %840, double %853)
%855 = fmul double 7.500000e-01, %854
%856 = call double @llvm.fmuladd.f64(double 2.500000e-01, double %829, double %855)
%857 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
store double %856, double* %857
%858 = load double*, double** %25
%859 = load i32, i32* %33
%860 = load i32, i32* %20
%861 = mul nsw i32 %859, %860
%862 = load i32, i32* %34
%863 = add nsw i32 %861, %862
%864 = mul nsw i32 2, %863
%865 = add nsw i32 %864, 1
%866 = sext i32 %865 to i64
%867 = getelementptr inbounds double, double* %858, i64 %866
%868 = load double, double* %867
%869 = load double*, double** %25
%870 = load i32, i32* %33
%871 = load i32, i32* %20
%872 = mul nsw i32 %870, %871
%873 = load i32, i32* %34
%874 = add nsw i32 %872, %873
%875 = add nsw i32 %874, 1
%876 = mul nsw i32 2, %875
%877 = add nsw i32 %876, 1
%878 = sext i32 %877 to i64
%879 = getelementptr inbounds double, double* %869, i64 %878
%880 = load double, double* %879
%881 = fmul double 2.500000e-01, %880
%882 = call double @llvm.fmuladd.f64(double 7.500000e-01, double %868, double %881)
%883 = load double*, double** %25
%884 = load i32, i32* %33
%885 = add nsw i32 %884, 1
%886 = load i32, i32* %20
%887 = mul nsw i32 %885, %886
%888 = load i32, i32* %34
%889 = add nsw i32 %887, %888
%890 = mul nsw i32 2, %889
%891 = add nsw i32 %890, 1
%892 = sext i32 %891 to i64
%893 = getelementptr inbounds double, double* %883, i64 %892
%894 = load double, double* %893
%895 = load double*, double** %25
%896 = load i32, i32* %33
%897 = add nsw i32 %896, 1
%898 = load i32, i32* %20
%899 = mul nsw i32 %897, %898
%900 = load i32, i32* %34
%901 = add nsw i32 %899, %900
%902 = add nsw i32 %901, 1
%903 = mul nsw i32 2, %902
%904 = add nsw i32 %903, 1
%905 = sext i32 %904 to i64
%906 = getelementptr inbounds double, double* %895, i64 %905
%907 = load double, double* %906
%908 = fmul double 2.500000e-01, %907
%909 = call double @llvm.fmuladd.f64(double 7.500000e-01, double %894, double %908)
%910 = fmul double 7.500000e-01, %909
%911 = call double @llvm.fmuladd.f64(double 2.500000e-01, double %882, double %910)
%912 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 1
store double %911, double* %912
%913 = load i32, i32* %33
%914 = load i32, i32* %34
%915 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
%916 = load double, double* %39
%917 = load double, double* %40
%918 = load i32, i32* %17
%919 = load i32, i32* %18
%920 = load double*, double** %19
%921 = load i32, i32* %20
%922 = load i32, i32* %21
%923 = load double*, double** %22
%924 = load double*, double** %23
%925 = load double*, double** %25
%926 = load double*, double** %26
%927 = load double*, double** %27
%928 = load double*, double** %28
%929 = load double*, double** %29
%930 = load double*, double** %30
%931 = load double*, double** %31
%932 = load double*, double** %32
%933 = call i32 @findNURBSbasisFunIso4xScCP(i32 %913, i32 %914, double 2.500000e-01, double 7.500000e-01, i32 12, double* %915, double %916, double %917, i32 %918, i32 %919, double* %920, i32 %921, i32 %922, double* %923, double* %924, double* %925, double* %926, double* %927, double* %928, double* %929, double* %930, double* %931, double* %932)
%934 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
%935 = load double, double* %934
%936 = load double*, double** %24
%937 = load i32, i32* %35
%938 = mul nsw i32 2, %937
%939 = sext i32 %938 to i64
%940 = getelementptr inbounds double, double* %936, i64 %939
store double %935, double* %940
%941 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 1
%942 = load double, double* %941
%943 = load double*, double** %24
%944 = load i32, i32* %35
%945 = mul nsw i32 2, %944
%946 = add nsw i32 %945, 1
%947 = sext i32 %946 to i64
%948 = getelementptr inbounds double, double* %943, i64 %947
store double %942, double* %948
%949 = load i32, i32* %35
%950 = add nsw i32 %949, 1
store i32 %950, i32* %35
%951 = load double*, double** %25
%952 = load i32, i32* %33
%953 = load i32, i32* %20
%954 = mul nsw i32 %952, %953
%955 = load i32, i32* %34
%956 = add nsw i32 %954, %955
%957 = mul nsw i32 2, %956
%958 = sext i32 %957 to i64
%959 = getelementptr inbounds double, double* %951, i64 %958
%960 = load double, double* %959
%961 = load double*, double** %25
%962 = load i32, i32* %33
%963 = load i32, i32* %20
%964 = mul nsw i32 %962, %963
%965 = load i32, i32* %34
%966 = add nsw i32 %964, %965
%967 = add nsw i32 %966, 1
%968 = mul nsw i32 2, %967
%969 = sext i32 %968 to i64
%970 = getelementptr inbounds double, double* %961, i64 %969
%971 = load double, double* %970
%972 = fmul double 5.000000e-01, %971
%973 = call double @llvm.fmuladd.f64(double 5.000000e-01, double %960, double %972)
%974 = load double*, double** %25
%975 = load i32, i32* %33
%976 = add nsw i32 %975, 1
%977 = load i32, i32* %20
%978 = mul nsw i32 %976, %977
%979 = load i32, i32* %34
%980 = add nsw i32 %978, %979
%981 = mul nsw i32 2, %980
%982 = sext i32 %981 to i64
%983 = getelementptr inbounds double, double* %974, i64 %982
%984 = load double, double* %983
%985 = load double*, double** %25
%986 = load i32, i32* %33
%987 = add nsw i32 %986, 1
%988 = load i32, i32* %20
%989 = mul nsw i32 %987, %988
%990 = load i32, i32* %34
%991 = add nsw i32 %989, %990
%992 = add nsw i32 %991, 1
%993 = mul nsw i32 2, %992
%994 = sext i32 %993 to i64
%995 = getelementptr inbounds double, double* %985, i64 %994
%996 = load double, double* %995
%997 = fmul double 5.000000e-01, %996
%998 = call double @llvm.fmuladd.f64(double 5.000000e-01, double %984, double %997)
%999 = fmul double 7.500000e-01, %998
%1000 = call double @llvm.fmuladd.f64(double 2.500000e-01, double %973, double %999)
%1001 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
store double %1000, double* %1001
%1002 = load double*, double** %25
%1003 = load i32, i32* %33
%1004 = load i32, i32* %20
%1005 = mul nsw i32 %1003, %1004
%1006 = load i32, i32* %34
%1007 = add nsw i32 %1005, %1006
%1008 = mul nsw i32 2, %1007
%1009 = add nsw i32 %1008, 1
%1010 = sext i32 %1009 to i64
%1011 = getelementptr inbounds double, double* %1002, i64 %1010
%1012 = load double, double* %1011
%1013 = load double*, double** %25
%1014 = load i32, i32* %33
%1015 = load i32, i32* %20
%1016 = mul nsw i32 %1014, %1015
%1017 = load i32, i32* %34
%1018 = add nsw i32 %1016, %1017
%1019 = add nsw i32 %1018, 1
%1020 = mul nsw i32 2, %1019
%1021 = add nsw i32 %1020, 1
%1022 = sext i32 %1021 to i64
%1023 = getelementptr inbounds double, double* %1013, i64 %1022
%1024 = load double, double* %1023
%1025 = fmul double 5.000000e-01, %1024
%1026 = call double @llvm.fmuladd.f64(double 5.000000e-01, double %1012, double %1025)
%1027 = load double*, double** %25
%1028 = load i32, i32* %33
%1029 = add nsw i32 %1028, 1
%1030 = load i32, i32* %20
%1031 = mul nsw i32 %1029, %1030
%1032 = load i32, i32* %34
%1033 = add nsw i32 %1031, %1032
%1034 = mul nsw i32 2, %1033
%1035 = add nsw i32 %1034, 1
%1036 = sext i32 %1035 to i64
%1037 = getelementptr inbounds double, double* %1027, i64 %1036
%1038 = load double, double* %1037
%1039 = load double*, double** %25
%1040 = load i32, i32* %33
%1041 = add nsw i32 %1040, 1
%1042 = load i32, i32* %20
%1043 = mul nsw i32 %1041, %1042
%1044 = load i32, i32* %34
%1045 = add nsw i32 %1043, %1044
%1046 = add nsw i32 %1045, 1
%1047 = mul nsw i32 2, %1046
%1048 = add nsw i32 %1047, 1
%1049 = sext i32 %1048 to i64
%1050 = getelementptr inbounds double, double* %1039, i64 %1049
%1051 = load double, double* %1050
%1052 = fmul double 5.000000e-01, %1051
%1053 = call double @llvm.fmuladd.f64(double 5.000000e-01, double %1038, double %1052)
%1054 = fmul double 7.500000e-01, %1053
%1055 = call double @llvm.fmuladd.f64(double 2.500000e-01, double %1026, double %1054)
%1056 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 1
store double %1055, double* %1056
%1057 = load i32, i32* %33
%1058 = load i32, i32* %34
%1059 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
%1060 = load double, double* %39
%1061 = load double, double* %40
%1062 = load i32, i32* %17
%1063 = load i32, i32* %18
%1064 = load double*, double** %19
%1065 = load i32, i32* %20
%1066 = load i32, i32* %21
%1067 = load double*, double** %22
%1068 = load double*, double** %23
%1069 = load double*, double** %25
%1070 = load double*, double** %26
%1071 = load double*, double** %27
%1072 = load double*, double** %28
%1073 = load double*, double** %29
%1074 = load double*, double** %30
%1075 = load double*, double** %31
%1076 = load double*, double** %32
%1077 = call i32 @findNURBSbasisFunIso4xScCP(i32 %1057, i32 %1058, double 2.500000e-01, double 5.000000e-01, i32 12, double* %1059, double %1060, double %1061, i32 %1062, i32 %1063, double* %1064, i32 %1065, i32 %1066, double* %1067, double* %1068, double* %1069, double* %1070, double* %1071, double* %1072, double* %1073, double* %1074, double* %1075, double* %1076)
%1078 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
%1079 = load double, double* %1078
%1080 = load double*, double** %24
%1081 = load i32, i32* %35
%1082 = mul nsw i32 2, %1081
%1083 = sext i32 %1082 to i64
%1084 = getelementptr inbounds double, double* %1080, i64 %1083
store double %1079, double* %1084
%1085 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 1
%1086 = load double, double* %1085
%1087 = load double*, double** %24
%1088 = load i32, i32* %35
%1089 = mul nsw i32 2, %1088
%1090 = add nsw i32 %1089, 1
%1091 = sext i32 %1090 to i64
%1092 = getelementptr inbounds double, double* %1087, i64 %1091
store double %1086, double* %1092
%1093 = load i32, i32* %35
%1094 = add nsw i32 %1093, 1
store i32 %1094, i32* %35
%1095 = load double*, double** %25
%1096 = load i32, i32* %33
%1097 = load i32, i32* %20
%1098 = mul nsw i32 %1096, %1097
%1099 = load i32, i32* %34
%1100 = add nsw i32 %1098, %1099
%1101 = mul nsw i32 2, %1100
%1102 = sext i32 %1101 to i64
%1103 = getelementptr inbounds double, double* %1095, i64 %1102
%1104 = load double, double* %1103
%1105 = load double*, double** %25
%1106 = load i32, i32* %33
%1107 = load i32, i32* %20
%1108 = mul nsw i32 %1106, %1107
%1109 = load i32, i32* %34
%1110 = add nsw i32 %1108, %1109
%1111 = add nsw i32 %1110, 1
%1112 = mul nsw i32 2, %1111
%1113 = sext i32 %1112 to i64
%1114 = getelementptr inbounds double, double* %1105, i64 %1113
%1115 = load double, double* %1114
%1116 = fmul double 7.500000e-01, %1115
%1117 = call double @llvm.fmuladd.f64(double 2.500000e-01, double %1104, double %1116)
%1118 = load double*, double** %25
%1119 = load i32, i32* %33
%1120 = add nsw i32 %1119, 1
%1121 = load i32, i32* %20
%1122 = mul nsw i32 %1120, %1121
%1123 = load i32, i32* %34
%1124 = add nsw i32 %1122, %1123
%1125 = mul nsw i32 2, %1124
%1126 = sext i32 %1125 to i64
%1127 = getelementptr inbounds double, double* %1118, i64 %1126
%1128 = load double, double* %1127
%1129 = load double*, double** %25
%1130 = load i32, i32* %33
%1131 = add nsw i32 %1130, 1
%1132 = load i32, i32* %20
%1133 = mul nsw i32 %1131, %1132
%1134 = load i32, i32* %34
%1135 = add nsw i32 %1133, %1134
%1136 = add nsw i32 %1135, 1
%1137 = mul nsw i32 2, %1136
%1138 = sext i32 %1137 to i64
%1139 = getelementptr inbounds double, double* %1129, i64 %1138
%1140 = load double, double* %1139
%1141 = fmul double 7.500000e-01, %1140
%1142 = call double @llvm.fmuladd.f64(double 2.500000e-01, double %1128, double %1141)
%1143 = fmul double 7.500000e-01, %1142
%1144 = call double @llvm.fmuladd.f64(double 2.500000e-01, double %1117, double %1143)
%1145 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
store double %1144, double* %1145
%1146 = load double*, double** %25
%1147 = load i32, i32* %33
%1148 = load i32, i32* %20
%1149 = mul nsw i32 %1147, %1148
%1150 = load i32, i32* %34
%1151 = add nsw i32 %1149, %1150
%1152 = mul nsw i32 2, %1151
%1153 = add nsw i32 %1152, 1
%1154 = sext i32 %1153 to i64
%1155 = getelementptr inbounds double, double* %1146, i64 %1154
%1156 = load double, double* %1155
%1157 = load double*, double** %25
%1158 = load i32, i32* %33
%1159 = load i32, i32* %20
%1160 = mul nsw i32 %1158, %1159
%1161 = load i32, i32* %34
%1162 = add nsw i32 %1160, %1161
%1163 = add nsw i32 %1162, 1
%1164 = mul nsw i32 2, %1163
%1165 = add nsw i32 %1164, 1
%1166 = sext i32 %1165 to i64
%1167 = getelementptr inbounds double, double* %1157, i64 %1166
%1168 = load double, double* %1167
%1169 = fmul double 7.500000e-01, %1168
%1170 = call double @llvm.fmuladd.f64(double 2.500000e-01, double %1156, double %1169)
%1171 = load double*, double** %25
%1172 = load i32, i32* %33
%1173 = add nsw i32 %1172, 1
%1174 = load i32, i32* %20
%1175 = mul nsw i32 %1173, %1174
%1176 = load i32, i32* %34
%1177 = add nsw i32 %1175, %1176
%1178 = mul nsw i32 2, %1177
%1179 = add nsw i32 %1178, 1
%1180 = sext i32 %1179 to i64
%1181 = getelementptr inbounds double, double* %1171, i64 %1180
%1182 = load double, double* %1181
%1183 = load double*, double** %25
%1184 = load i32, i32* %33
%1185 = add nsw i32 %1184, 1
%1186 = load i32, i32* %20
%1187 = mul nsw i32 %1185, %1186
%1188 = load i32, i32* %34
%1189 = add nsw i32 %1187, %1188
%1190 = add nsw i32 %1189, 1
%1191 = mul nsw i32 2, %1190
%1192 = add nsw i32 %1191, 1
%1193 = sext i32 %1192 to i64
%1194 = getelementptr inbounds double, double* %1183, i64 %1193
%1195 = load double, double* %1194
%1196 = fmul double 7.500000e-01, %1195
%1197 = call double @llvm.fmuladd.f64(double 2.500000e-01, double %1182, double %1196)
%1198 = fmul double 7.500000e-01, %1197
%1199 = call double @llvm.fmuladd.f64(double 2.500000e-01, double %1170, double %1198)
%1200 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 1
store double %1199, double* %1200
%1201 = load i32, i32* %33
%1202 = load i32, i32* %34
%1203 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
%1204 = load double, double* %39
%1205 = load double, double* %40
%1206 = load i32, i32* %17
%1207 = load i32, i32* %18
%1208 = load double*, double** %19
%1209 = load i32, i32* %20
%1210 = load i32, i32* %21
%1211 = load double*, double** %22
%1212 = load double*, double** %23
%1213 = load double*, double** %25
%1214 = load double*, double** %26
%1215 = load double*, double** %27
%1216 = load double*, double** %28
%1217 = load double*, double** %29
%1218 = load double*, double** %30
%1219 = load double*, double** %31
%1220 = load double*, double** %32
%1221 = call i32 @findNURBSbasisFunIso4xScCP(i32 %1201, i32 %1202, double 2.500000e-01, double 2.500000e-01, i32 12, double* %1203, double %1204, double %1205, i32 %1206, i32 %1207, double* %1208, i32 %1209, i32 %1210, double* %1211, double* %1212, double* %1213, double* %1214, double* %1215, double* %1216, double* %1217, double* %1218, double* %1219, double* %1220)
%1222 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 0
%1223 = load double, double* %1222
%1224 = load double*, double** %24
%1225 = load i32, i32* %35
%1226 = mul nsw i32 2, %1225
%1227 = sext i32 %1226 to i64
%1228 = getelementptr inbounds double, double* %1224, i64 %1227
store double %1223, double* %1228
%1229 = getelementptr inbounds [2 x double], [2 x double]* %38, i64 0, i64 1
%1230 = load double, double* %1229
%1231 = load double*, double** %24
%1232 = load i32, i32* %35
%1233 = mul nsw i32 2, %1232
%1234 = add nsw i32 %1233, 1
%1235 = sext i32 %1234 to i64
%1236 = getelementptr inbounds double, double* %1231, i64 %1235
store double %1230, double* %1236
%1237 = load i32, i32* %35
%1238 = add nsw i32 %1237, 1
store i32 %1238, i32* %35
br label %1239
1239: ; preds = %71
%1240 = load i32, i32* %34
%1241 = add nsw i32 %1240, 1
store i32 %1241, i32* %34
br label %66
1242: ; preds = %66
br label %1243
1243: ; preds = %1242
%1244 = load i32, i32* %33
%1245 = add nsw i32 %1244, 1
store i32 %1245, i32* %33
br label %45
1246: ; preds = %45
ret void
}

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