#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*/ findNURBSbasisFunIso2xCP(int, int, int, int, double, double,
                                            int, double *, double, double, int,
                                            int, double *, int, int, double *,
                                            double *, double *, double *,
                                            double *, double *, double *,
                                            double *, double *, double *);
void NURBSsurfaceBasisX2Max(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 - 1); ii++) {
    stepV = 0.1 * (knotV[ii + orderV] - knotV[ii]);
    for (jj = 0; jj <= (ncp - 2); jj++) {
      stepU = 0.1 * (knotU[jj + 1 + orderU] - knotU[jj]);
      uv[0] = 0.75 * usX1max[2 * (ii * ncp + jj)] +
              0.25 * usX1max[2 * (ii * ncp + jj + 1)];
      uv[1] = 0.75 * usX1max[2 * (ii * ncp + jj) + 1] +
              0.25 * usX1max[2 * (ii * ncp + jj + 1) + 1];
      findNURBSbasisFunIso2xCP(ii, jj, ii, jj + 1, 0.75, 0.25, 18, 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.666666666667 * uv[0] +
              0.33333333333 * usX1max[2 * (ii * ncp + jj + 1)];
      uv[1] = 0.666666666667 * uv[1] +
              0.33333333333 * usX1max[2 * (ii * ncp + jj + 1) + 1];
      findNURBSbasisFunIso2xCP(ii, jj, ii, jj + 1, 0.5, 0.5, 16, 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 * uv[0] + 0.5 * usX1max[2 * (ii * ncp + jj + 1)];
      uv[1] = 0.5 * uv[1] + 0.5 * usX1max[2 * (ii * ncp + jj + 1) + 1];
      findNURBSbasisFunIso2xCP(ii, jj, ii, jj + 1, 0.25, 0.75, 14, 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++;
    }
  }
  for (jj = 0; jj <= (ncp - 1); jj++) {
    stepU = 0.1 * (knotU[jj + orderU] - knotU[jj]);
    for (ii = 0; ii <= (kcp - 2); ii++) {
      stepV = 0.1 * (knotV[ii + 1 + orderV] - knotV[ii]);
      uv[0] = 0.75 * usX1max[2 * (ii * ncp + jj)] +
              0.25 * usX1max[2 * ((ii + 1) * ncp + jj)];
      uv[1] = 0.75 * usX1max[2 * (ii * ncp + jj) + 1] +
              0.25 * usX1max[2 * ((ii + 1) * ncp + jj) + 1];
      findNURBSbasisFunIso2xCP(ii, jj, ii + 1, jj, 0.75, 0.25, 18, 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.666666666667 * uv[0] +
              0.33333333333 * usX1max[2 * ((ii + 1) * ncp + jj)];
      uv[1] = 0.666666666667 * uv[1] +
              0.33333333333 * usX1max[2 * ((ii + 1) * ncp + jj) + 1];
      findNURBSbasisFunIso2xCP(ii, jj, ii + 1, jj, 0.5, 0.5, 16, 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 * uv[0] + 0.5 * usX1max[2 * ((ii + 1) * ncp + jj)];
      uv[1] = 0.5 * uv[1] + 0.5 * usX1max[2 * ((ii + 1) * ncp + jj) + 1];
      findNURBSbasisFunIso2xCP(ii, jj, ii + 1, jj, 0.25, 0.75, 14, 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):
<NURBSsurfaceBasisX2Max>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1f8,%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    $0x1,%ecx
cmp    %ecx,%eax
jg     17c7 <NURBSsurfaceBasisX2Max+0x6b7>
mov    0x10(%rbp),%rax
mov    -0x4c(%rbp),%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  0xe47(%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     17b4 <NURBSsurfaceBasisX2Max+0x6a4>
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  0xdfc(%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  0xdc3(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0xdbe(%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  0xd6b(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0xd66(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x4c(%rbp),%edi
mov    -0x50(%rbp),%esi
mov    -0x4c(%rbp),%edx
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
lea    -0x70(%rbp),%r9
movsd  -0x78(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm3
mov    -0x2c(%rbp),%eax
mov    -0x30(%rbp),%r8d
mov    %r8d,-0x10c(%rbp)
mov    -0x38(%rbp),%r8
mov    %r8,-0x108(%rbp)
mov    -0x3c(%rbp),%r8d
mov    %r8d,-0x100(%rbp)
mov    -0x40(%rbp),%r8d
mov    %r8d,-0xfc(%rbp)
mov    -0x48(%rbp),%r8
mov    %r8,-0xf8(%rbp)
mov    0x10(%rbp),%r8
mov    %r8,-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),%r8
mov    %r8,-0xe8(%rbp)
movsd  0xcc8(%rip),%xmm0
movsd  0xcb8(%rip),%xmm1
mov    $0x12,%r8d
mov    %eax,(%rsp)
mov    -0x10c(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0x108(%rbp),%rax
mov    %rax,0x10(%rsp)
mov    -0x100(%rbp),%eax
mov    %eax,0x18(%rsp)
mov    -0xfc(%rbp),%eax
mov    %eax,0x20(%rsp)
mov    -0xf8(%rbp),%rax
mov    %rax,0x28(%rsp)
mov    -0xf0(%rbp),%rax
mov    %rax,0x30(%rsp)
mov    -0xe8(%rbp),%rax
mov    %r13,0x38(%rsp)
mov    %r12,0x40(%rsp)
mov    %r15,0x48(%rsp)
mov    %r14,0x50(%rsp)
mov    %rbx,0x58(%rsp)
mov    %r11,0x60(%rsp)
mov    %r10,0x68(%rsp)
mov    %rax,0x70(%rsp)
call   1030 <findNURBSbasisFunIso2xCP@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)
movsd  -0x70(%rbp),%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  0xbfb(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0xbe6(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%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  0xbba(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0xba5(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x4c(%rbp),%edi
mov    -0x50(%rbp),%esi
mov    -0x4c(%rbp),%edx
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
lea    -0x70(%rbp),%r9
movsd  -0x78(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm3
mov    -0x2c(%rbp),%eax
mov    -0x30(%rbp),%r8d
mov    %r8d,-0xdc(%rbp)
mov    -0x38(%rbp),%r8
mov    %r8,-0xd8(%rbp)
mov    -0x3c(%rbp),%r8d
mov    %r8d,-0xd0(%rbp)
mov    -0x40(%rbp),%r8d
mov    %r8d,-0xcc(%rbp)
mov    -0x48(%rbp),%r8
mov    %r8,-0xc8(%rbp)
mov    0x10(%rbp),%r8
mov    %r8,-0xc0(%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),%r8
mov    %r8,-0xb8(%rbp)
movsd  0xaff(%rip),%xmm1
mov    $0x10,%r8d
movaps %xmm1,%xmm0
mov    %eax,(%rsp)
mov    -0xdc(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0xd8(%rbp),%rax
mov    %rax,0x10(%rsp)
mov    -0xd0(%rbp),%eax
mov    %eax,0x18(%rsp)
mov    -0xcc(%rbp),%eax
mov    %eax,0x20(%rsp)
mov    -0xc8(%rbp),%rax
mov    %rax,0x28(%rsp)
mov    -0xc0(%rbp),%rax
mov    %rax,0x30(%rsp)
mov    -0xb8(%rbp),%rax
mov    %r13,0x38(%rsp)
mov    %r12,0x40(%rsp)
mov    %r15,0x48(%rsp)
mov    %r14,0x50(%rsp)
mov    %rbx,0x58(%rsp)
mov    %r11,0x60(%rsp)
mov    %r10,0x68(%rsp)
mov    %rax,0x70(%rsp)
call   1030 <findNURBSbasisFunIso2xCP@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)
movsd  -0x70(%rbp),%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  0xa1f(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0xa12(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%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  0x9de(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x9d1(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x4c(%rbp),%edi
mov    -0x50(%rbp),%esi
mov    -0x4c(%rbp),%edx
mov    -0x50(%rbp),%ecx
add    $0x1,%ecx
lea    -0x70(%rbp),%r9
movsd  -0x78(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm3
mov    -0x2c(%rbp),%eax
mov    -0x30(%rbp),%r8d
mov    %r8d,-0xac(%rbp)
mov    -0x38(%rbp),%r8
mov    %r8,-0xa8(%rbp)
mov    -0x3c(%rbp),%r8d
mov    %r8d,-0xa0(%rbp)
mov    -0x40(%rbp),%r8d
mov    %r8d,-0x9c(%rbp)
mov    -0x48(%rbp),%r8
mov    %r8,-0x98(%rbp)
mov    0x10(%rbp),%r8
mov    %r8,-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),%r8
mov    %r8,-0x88(%rbp)
movsd  0x923(%rip),%xmm0
movsd  0x923(%rip),%xmm1
mov    $0xe,%r8d
mov    %eax,(%rsp)
mov    -0xac(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0xa8(%rbp),%rax
mov    %rax,0x10(%rsp)
mov    -0xa0(%rbp),%eax
mov    %eax,0x18(%rsp)
mov    -0x9c(%rbp),%eax
mov    %eax,0x20(%rsp)
mov    -0x98(%rbp),%rax
mov    %rax,0x28(%rsp)
mov    -0x90(%rbp),%rax
mov    %rax,0x30(%rsp)
mov    -0x88(%rbp),%rax
mov    %r13,0x38(%rsp)
mov    %r12,0x40(%rsp)
mov    %r15,0x48(%rsp)
mov    %r14,0x50(%rsp)
mov    %rbx,0x58(%rsp)
mov    %r11,0x60(%rsp)
mov    %r10,0x68(%rsp)
mov    %rax,0x70(%rsp)
call   1030 <findNURBSbasisFunIso2xCP@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    11c9 <NURBSsurfaceBasisX2Max+0xb9>
jmp    17b9 <NURBSsurfaceBasisX2Max+0x6a9>
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1181 <NURBSsurfaceBasisX2Max+0x71>
movl   $0x0,-0x50(%rbp)
mov    -0x50(%rbp),%eax
mov    -0x3c(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1e14 <NURBSsurfaceBasisX2Max+0xd04>
mov    -0x48(%rbp),%rax
mov    -0x50(%rbp),%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  0x7fa(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x78(%rbp)
movl   $0x0,-0x4c(%rbp)
mov    -0x4c(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    $0x2,%ecx
cmp    %ecx,%eax
jg     1e01 <NURBSsurfaceBasisX2Max+0xcf1>
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  0x7af(%rip),%xmm0
mulsd  %xmm1,%xmm0
movsd  %xmm0,-0x80(%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
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x776(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x771(%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
add    $0x1,%ecx
imul   -0x3c(%rbp),%ecx
add    -0x50(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  0x71e(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x719(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x4c(%rbp),%edi
mov    -0x50(%rbp),%esi
mov    -0x4c(%rbp),%edx
add    $0x1,%edx
mov    -0x50(%rbp),%ecx
lea    -0x70(%rbp),%r9
movsd  -0x78(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm3
mov    -0x2c(%rbp),%eax
mov    -0x30(%rbp),%r8d
mov    %r8d,-0x19c(%rbp)
mov    -0x38(%rbp),%r8
mov    %r8,-0x198(%rbp)
mov    -0x3c(%rbp),%r8d
mov    %r8d,-0x190(%rbp)
mov    -0x40(%rbp),%r8d
mov    %r8d,-0x18c(%rbp)
mov    -0x48(%rbp),%r8
mov    %r8,-0x188(%rbp)
mov    0x10(%rbp),%r8
mov    %r8,-0x180(%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),%r8
mov    %r8,-0x178(%rbp)
movsd  0x67b(%rip),%xmm0
movsd  0x66b(%rip),%xmm1
mov    $0x12,%r8d
mov    %eax,(%rsp)
mov    -0x19c(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0x198(%rbp),%rax
mov    %rax,0x10(%rsp)
mov    -0x190(%rbp),%eax
mov    %eax,0x18(%rsp)
mov    -0x18c(%rbp),%eax
mov    %eax,0x20(%rsp)
mov    -0x188(%rbp),%rax
mov    %rax,0x28(%rsp)
mov    -0x180(%rbp),%rax
mov    %rax,0x30(%rsp)
mov    -0x178(%rbp),%rax
mov    %r13,0x38(%rsp)
mov    %r12,0x40(%rsp)
mov    %r15,0x48(%rsp)
mov    %r14,0x50(%rsp)
mov    %rbx,0x58(%rsp)
mov    %r11,0x60(%rsp)
mov    %r10,0x68(%rsp)
mov    %rax,0x70(%rsp)
call   1030 <findNURBSbasisFunIso2xCP@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)
movsd  -0x70(%rbp),%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  0x5ae(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x599(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%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  0x56d(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x558(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x4c(%rbp),%edi
mov    -0x50(%rbp),%esi
mov    -0x4c(%rbp),%edx
add    $0x1,%edx
mov    -0x50(%rbp),%ecx
lea    -0x70(%rbp),%r9
movsd  -0x78(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm3
mov    -0x2c(%rbp),%eax
mov    -0x30(%rbp),%r8d
mov    %r8d,-0x16c(%rbp)
mov    -0x38(%rbp),%r8
mov    %r8,-0x168(%rbp)
mov    -0x3c(%rbp),%r8d
mov    %r8d,-0x160(%rbp)
mov    -0x40(%rbp),%r8d
mov    %r8d,-0x15c(%rbp)
mov    -0x48(%rbp),%r8
mov    %r8,-0x158(%rbp)
mov    0x10(%rbp),%r8
mov    %r8,-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),%r8
mov    %r8,-0x148(%rbp)
movsd  0x4b2(%rip),%xmm1
mov    $0x10,%r8d
movaps %xmm1,%xmm0
mov    %eax,(%rsp)
mov    -0x16c(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0x168(%rbp),%rax
mov    %rax,0x10(%rsp)
mov    -0x160(%rbp),%eax
mov    %eax,0x18(%rsp)
mov    -0x15c(%rbp),%eax
mov    %eax,0x20(%rsp)
mov    -0x158(%rbp),%rax
mov    %rax,0x28(%rsp)
mov    -0x150(%rbp),%rax
mov    %rax,0x30(%rsp)
mov    -0x148(%rbp),%rax
mov    %r13,0x38(%rsp)
mov    %r12,0x40(%rsp)
mov    %r15,0x48(%rsp)
mov    %r14,0x50(%rsp)
mov    %rbx,0x58(%rsp)
mov    %r11,0x60(%rsp)
mov    %r10,0x68(%rsp)
mov    %rax,0x70(%rsp)
call   1030 <findNURBSbasisFunIso2xCP@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)
movsd  -0x70(%rbp),%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  0x3d2(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x3c5(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x70(%rbp)
movsd  -0x68(%rbp),%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  0x391(%rip),%xmm1
mulsd  (%rax,%rcx,8),%xmm1
movsd  0x384(%rip),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x4c(%rbp),%edi
mov    -0x50(%rbp),%esi
mov    -0x4c(%rbp),%edx
add    $0x1,%edx
mov    -0x50(%rbp),%ecx
lea    -0x70(%rbp),%r9
movsd  -0x78(%rbp),%xmm2
movsd  -0x80(%rbp),%xmm3
mov    -0x2c(%rbp),%eax
mov    -0x30(%rbp),%r8d
mov    %r8d,-0x13c(%rbp)
mov    -0x38(%rbp),%r8
mov    %r8,-0x138(%rbp)
mov    -0x3c(%rbp),%r8d
mov    %r8d,-0x130(%rbp)
mov    -0x40(%rbp),%r8d
mov    %r8d,-0x12c(%rbp)
mov    -0x48(%rbp),%r8
mov    %r8,-0x128(%rbp)
mov    0x10(%rbp),%r8
mov    %r8,-0x120(%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),%r8
mov    %r8,-0x118(%rbp)
movsd  0x2d6(%rip),%xmm0
movsd  0x2d6(%rip),%xmm1
mov    $0xe,%r8d
mov    %eax,(%rsp)
mov    -0x13c(%rbp),%eax
mov    %eax,0x8(%rsp)
mov    -0x138(%rbp),%rax
mov    %rax,0x10(%rsp)
mov    -0x130(%rbp),%eax
mov    %eax,0x18(%rsp)
mov    -0x12c(%rbp),%eax
mov    %eax,0x20(%rsp)
mov    -0x128(%rbp),%rax
mov    %rax,0x28(%rsp)
mov    -0x120(%rbp),%rax
mov    %rax,0x30(%rsp)
mov    -0x118(%rbp),%rax
mov    %r13,0x38(%rsp)
mov    %r12,0x40(%rsp)
mov    %r15,0x48(%rsp)
mov    %r14,0x50(%rsp)
mov    %rbx,0x58(%rsp)
mov    %r11,0x60(%rsp)
mov    %r10,0x68(%rsp)
mov    %rax,0x70(%rsp)
call   1030 <findNURBSbasisFunIso2xCP@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    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
jmp    1816 <NURBSsurfaceBasisX2Max+0x706>
jmp    1e06 <NURBSsurfaceBasisX2Max+0xcf6>
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
jmp    17ce <NURBSsurfaceBasisX2Max+0x6be>
add    $0x1f8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<NURBSsurfaceBasisX2Max>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xb8,%rsp
mov    %rdx,%r10
mov    %esi,%r11d
mov    %rdi,0x38(%rsp)
lea    0x1(%rdi),%eax
lea    0x1(%r11),%edx
cltq
movslq %edx,%r12
test   %r8d,%r8d
mov    %r9,0x30(%rsp)
mov    %r8,0x28(%rsp)
mov    %rcx,0x20(%rsp)
mov    %r10,0x48(%rsp)
mov    %r11,0x40(%rsp)
mov    %r12,0xa8(%rsp)
mov    %rax,0xb0(%rsp)
jle    15ec <NURBSsurfaceBasisX2Max+0x4dc>
lea    -0x1(%rcx),%ebp
mov    %r8d,%edx
mov    %rdx,0x80(%rsp)
lea    (%rcx,%rcx,1),%edx
mov    %rdx,0x78(%rsp)
lea    (%r9,%rax,8),%r9
add    $0x8,%r9
xor    %r14d,%r14d
movsd  0xe6d(%rip),%xmm0
movapd 0xe85(%rip),%xmm6
movapd 0xe8d(%rip),%xmm3
movsd  0xe5d(%rip),%xmm4
movsd  0xe5d(%rip),%xmm1
xor    %ebx,%ebx
xor    %r8d,%r8d
mov    %rbp,0x90(%rsp)
mov    %r9,0x88(%rsp)
jmp    11f9 <NURBSsurfaceBasisX2Max+0xe9>
nopw   0x0(%rax,%rax,1)
mov    0x60(%rsp),%rbx
add    $0x1,%rbx
add    0x78(%rsp),%r14
cmp    0x80(%rsp),%rbx
mov    0x20(%rsp),%rcx
mov    0xa8(%rsp),%r12
je     15ef <NURBSsurfaceBasisX2Max+0x4df>
lea    (%rbx,%r12,1),%rax
mov    0xf0(%rsp),%rdx
movsd  (%rdx,%rax,8),%xmm5
mov    %rbx,%rax
subsd  (%rdx,%rbx,8),%xmm5
mulsd  %xmm0,%xmm5
cmp    $0x2,%ecx
mov    %rbx,0x60(%rsp)
jl     11d0 <NURBSsurfaceBasisX2Max+0xc0>
lea    (%r8,%r8,1),%ebx
add    $0x5,%ebx
xor    %r12d,%r12d
xor    %r13d,%r13d
movsd  %xmm5,0x18(%rsp)
xor    %esi,%esi
mov    %r14,0x58(%rsp)
nopw   0x0(%rax,%rax,1)
mov    %r8,0xa0(%rsp)
movsd  (%r9,%r12,4),%xmm5
mov    0x30(%rsp),%rax
subsd  (%rax,%r12,4),%xmm5
mov    %rax,%r15
add    $0x1,%r13
mulsd  %xmm0,%xmm5
movapd %xmm5,%xmm2
movsd  %xmm5,0x50(%rsp)
lea    (%r14,%r12,1),%rax
cltq
lea    0x2(%rax),%ecx
movslq %ecx,%rdi
mov    %rdi,0x70(%rsp)
lea    0x1(%rax),%ecx
lea    0x3(%rax),%edx
movslq %edx,%rdx
mov    %rdx,0x68(%rsp)
mov    0x100(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm0
movhpd 0x0(%rbp,%rdx,8),%xmm0
movslq %ecx,%rcx
movsd  0x0(%rbp,%rax,8),%xmm5
movhpd 0x0(%rbp,%rcx,8),%xmm5
mov    %rbp,%rax
mulpd  %xmm6,%xmm0
mulpd  %xmm3,%xmm5
addpd  %xmm0,%xmm5
movapd %xmm5,(%rsp)
sub    $0x8,%rsp
mov    0x68(%rsp),%rbp
mov    %ebp,%edi
mov    %ebp,%edx
mov    %r13d,%ecx
movaps %xmm4,%xmm0
mov    %rsi,%r14
mov    %rsi,0xa0(%rsp)
mov    $0x12,%r8d
lea    0x8(%rsp),%r9
movsd  0x20(%rsp),%xmm3
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   %rax
mov    0x138(%rsp),%rax
push   %rax
push   %r15
push   0x80(%rsp)
push   0x80(%rsp)
push   %r10
push   %r11
push   0xb0(%rsp)
call   1030 <findNURBSbasisFunIso2xCP@plt>
add    $0x80,%rsp
lea    -0x5(%rbx),%eax
cltq
movapd (%rsp),%xmm0
mov    0xf8(%rsp),%rcx
movlpd %xmm0,(%rcx,%rax,8)
lea    -0x4(%rbx),%eax
cltq
mov    0xf8(%rsp),%rcx
movhpd %xmm0,(%rcx,%rax,8)
mov    0x100(%rsp),%rax
mov    0x70(%rsp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    0x68(%rsp),%rcx
movhpd (%rax,%rcx,8),%xmm1
mulpd  0xc9e(%rip),%xmm1
mulpd  0xca6(%rip),%xmm0
addpd  %xmm1,%xmm0
movapd %xmm0,(%rsp)
sub    $0x8,%rsp
mov    %ebp,%edi
mov    %r14d,%esi
mov    %ebp,%edx
mov    %r13d,%ecx
movsd  0xc4f(%rip),%xmm0
movaps %xmm0,%xmm1
mov    $0x10,%r8d
lea    0x8(%rsp),%r9
movsd  0x58(%rsp),%xmm2
movsd  0x20(%rsp),%xmm3
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   %rax
push   0x138(%rsp)
push   %r15
mov    0x80(%rsp),%r15
push   %r15
mov    0x80(%rsp),%r14
push   %r14
push   0xb0(%rsp)
push   0xb0(%rsp)
push   0xb0(%rsp)
call   1030 <findNURBSbasisFunIso2xCP@plt>
add    $0x80,%rsp
lea    -0x3(%rbx),%eax
cltq
movapd (%rsp),%xmm0
mov    0xf8(%rsp),%rcx
movlpd %xmm0,(%rcx,%rax,8)
lea    -0x2(%rbx),%eax
cltq
mov    0xf8(%rsp),%rcx
movhpd %xmm0,(%rcx,%rax,8)
mov    0x70(%rsp),%rax
mov    0x100(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm1
mov    0x68(%rsp),%rax
movhpd (%rcx,%rax,8),%xmm1
mov    %rcx,%rax
movapd 0xbbd(%rip),%xmm2
mulpd  %xmm2,%xmm1
mulpd  %xmm2,%xmm0
addpd  %xmm1,%xmm0
movapd %xmm0,(%rsp)
sub    $0x8,%rsp
mov    %ebp,%edi
mov    0xa0(%rsp),%rsi
mov    %ebp,%edx
mov    %r13d,%ecx
movsd  0xb41(%rip),%xmm0
movsd  0xb31(%rip),%xmm1
mov    $0xe,%r8d
lea    0x8(%rsp),%r9
movsd  0x58(%rsp),%xmm2
movsd  0x20(%rsp),%xmm3
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   %rax
push   0x138(%rsp)
push   0x80(%rsp)
push   %r15
push   %r14
push   0xb0(%rsp)
push   0xb0(%rsp)
push   0xb0(%rsp)
call   1030 <findNURBSbasisFunIso2xCP@plt>
movsd  0xabc(%rip),%xmm1
movsd  0xaac(%rip),%xmm4
movapd 0xacc(%rip),%xmm3
movapd 0xab4(%rip),%xmm6
mov    0xd8(%rsp),%r14
mov    0x108(%rsp),%r9
mov    0x120(%rsp),%r8
mov    0x178(%rsp),%rcx
mov    0xc0(%rsp),%r11
mov    0xc8(%rsp),%r10
add    $0x80,%rsp
movsd  (%rsp),%xmm0
lea    -0x1(%rbx),%eax
cltq
movsd  %xmm0,(%rcx,%rax,8)
movsd  0x8(%rsp),%xmm0
movslq %ebx,%rbx
movsd  %xmm0,(%rcx,%rbx,8)
movsd  0xa38(%rip),%xmm0
add    $0x6,%ebx
add    $0x3,%r8d
add    $0x2,%r12
mov    %r13,%rsi
mov    0x90(%rsp),%rax
cmp    %rax,%r13
jne    1240 <NURBSsurfaceBasisX2Max+0x130>
jmp    11d0 <NURBSsurfaceBasisX2Max+0xc0>
xor    %r8d,%r8d
test   %ecx,%ecx
mov    0x28(%rsp),%rdi
jle    1a7e <NURBSsurfaceBasisX2Max+0x96e>
lea    -0x1(%rdi),%edx
mov    0x20(%rsp),%rax
mov    %eax,%ecx
mov    %rcx,0x78(%rsp)
lea    (%rax,%rax,1),%esi
mov    $0x1,%ebx
xor    %ebp,%ebp
movsd  0x9e3(%rip),%xmm0
movapd 0x9fb(%rip),%xmm2
movapd 0xa03(%rip),%xmm6
movsd  0x9d3(%rip),%xmm4
movsd  0x9d3(%rip),%xmm1
mov    %rdx,0x90(%rsp)
mov    %rsi,0x88(%rsp)
jmp    1673 <NURBSsurfaceBasisX2Max+0x563>
nop
mov    0x58(%rsp),%rbp
add    $0x1,%rbp
mov    0x80(%rsp),%ebx
add    $0x2,%ebx
cmp    0x78(%rsp),%rbp
mov    0x28(%rsp),%rdi
je     1a7e <NURBSsurfaceBasisX2Max+0x96e>
mov    0xb0(%rsp),%rax
add    %rbp,%rax
mov    0x30(%rsp),%rcx
movsd  (%rcx,%rax,8),%xmm5
mov    %rbp,%r9
subsd  (%rcx,%rbp,8),%xmm5
mulsd  %xmm0,%xmm5
cmp    $0x2,%edi
mov    %ebx,0x80(%rsp)
mov    %rbp,0x58(%rsp)
jl     1650 <NURBSsurfaceBasisX2Max+0x540>
lea    (%r8,%r8,1),%r13d
add    $0x5,%r13d
mov    0xf0(%rsp),%r15
mov    %ebx,%eax
xor    %edi,%edi
xor    %ebp,%ebp
movsd  %xmm5,0x18(%rsp)
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    %r15,0x68(%rsp)
mov    %r8,0xa0(%rsp)
add    $0x1,%rbp
movsd  0x8(%r15,%r12,8),%xmm5
subsd  (%r15),%xmm5
mulsd  %xmm0,%xmm5
movapd %xmm5,%xmm3
movsd  %xmm5,0x50(%rsp)
lea    -0x1(%rax),%ecx
movslq %ecx,%rcx
lea    (%rsi,%rax,1),%ebx
mov    %ebx,0x70(%rsp)
lea    -0x1(%rsi,%rax,1),%edx
movslq %edx,%rsi
movslq %ebx,%r15
mov    0x100(%rsp),%rbx
movsd  (%rbx,%rsi,8),%xmm0
mov    %rsi,%r14
movhpd (%rbx,%r15,8),%xmm0
mov    %r15,0x98(%rsp)
cltq
movsd  (%rbx,%rcx,8),%xmm5
movhpd (%rbx,%rax,8),%xmm5
mov    %rbx,%rax
mulpd  %xmm2,%xmm0
mulpd  %xmm6,%xmm5
addpd  %xmm0,%xmm5
movapd %xmm5,(%rsp)
sub    $0x8,%rsp
mov    0x60(%rsp),%r12
mov    %r12d,%esi
mov    %ebp,%edx
mov    %r12d,%ecx
movaps %xmm4,%xmm0
mov    %rdi,%rbx
mov    %rdi,0x68(%rsp)
mov    $0x12,%r8d
lea    0x8(%rsp),%r9
movsd  0x20(%rsp),%xmm2
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   %rax
mov    0x138(%rsp),%rax
push   %rax
push   0x80(%rsp)
push   0x80(%rsp)
push   0x80(%rsp)
push   %r10
push   %r11
push   0xb0(%rsp)
call   1030 <findNURBSbasisFunIso2xCP@plt>
add    $0x80,%rsp
lea    -0x5(%r13),%eax
cltq
movapd (%rsp),%xmm0
mov    0xf8(%rsp),%rcx
movlpd %xmm0,(%rcx,%rax,8)
lea    -0x4(%r13),%eax
cltq
mov    0xf8(%rsp),%rcx
movhpd %xmm0,(%rcx,%rax,8)
mov    0x100(%rsp),%rax
movsd  (%rax,%r14,8),%xmm1
movhpd (%rax,%r15,8),%xmm1
mulpd  0x815(%rip),%xmm1
mulpd  0x81d(%rip),%xmm0
addpd  %xmm1,%xmm0
movapd %xmm0,(%rsp)
sub    $0x8,%rsp
mov    %ebx,%edi
mov    %r12d,%esi
mov    %ebp,%edx
mov    %r12d,%ecx
movsd  0x7c6(%rip),%xmm0
movaps %xmm0,%xmm1
mov    $0x10,%r8d
lea    0x8(%rsp),%r9
movsd  0x20(%rsp),%xmm2
movsd  0x58(%rsp),%xmm3
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   %rax
push   0x138(%rsp)
push   0x80(%rsp)
mov    0x80(%rsp),%rbx
push   %rbx
mov    0x80(%rsp),%r15
push   %r15
push   0xb0(%rsp)
push   0xb0(%rsp)
push   0xb0(%rsp)
call   1030 <findNURBSbasisFunIso2xCP@plt>
add    $0x80,%rsp
lea    -0x3(%r13),%eax
cltq
movapd (%rsp),%xmm0
mov    0xf8(%rsp),%rcx
movlpd %xmm0,(%rcx,%rax,8)
lea    -0x2(%r13),%eax
cltq
mov    0xf8(%rsp),%rcx
movhpd %xmm0,(%rcx,%rax,8)
mov    0x100(%rsp),%rax
movsd  (%rax,%r14,8),%xmm1
mov    %rsp,%r9
mov    0x98(%rsp),%rcx
movhpd (%rax,%rcx,8),%xmm1
movapd 0x72f(%rip),%xmm2
mulpd  %xmm2,%xmm1
mulpd  %xmm2,%xmm0
addpd  %xmm1,%xmm0
movapd %xmm0,(%rsp)
sub    $0x8,%rsp
mov    0x68(%rsp),%rdi
mov    %r12d,%esi
mov    %ebp,%edx
mov    %r12d,%ecx
movsd  0x6b5(%rip),%xmm0
movsd  0x6a5(%rip),%xmm1
mov    $0xe,%r8d
movsd  0x20(%rsp),%xmm2
movsd  0x58(%rsp),%xmm3
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   0x140(%rsp)
push   %rax
push   0x138(%rsp)
push   0x80(%rsp)
push   %rbx
push   %r15
push   0xb0(%rsp)
push   0xb0(%rsp)
push   0xb0(%rsp)
call   1030 <findNURBSbasisFunIso2xCP@plt>
movsd  0x636(%rip),%xmm1
movsd  0x626(%rip),%xmm4
movapd 0x646(%rip),%xmm6
movapd 0x62e(%rip),%xmm2
mov    0x108(%rsp),%rsi
mov    0x110(%rsp),%rdx
mov    0x120(%rsp),%r8
mov    0x178(%rsp),%rcx
mov    0x128(%rsp),%r12
mov    0xc0(%rsp),%r11
mov    0xc8(%rsp),%r10
add    $0x80,%rsp
movsd  (%rsp),%xmm0
lea    -0x1(%r13),%eax
cltq
movsd  %xmm0,(%rcx,%rax,8)
movsd  0x8(%rsp),%xmm0
movslq %r13d,%r13
movsd  %xmm0,(%rcx,%r13,8)
mov    0x68(%rsp),%r15
movsd  0x5a3(%rip),%xmm0
add    $0x6,%r13d
add    $0x3,%r8d
add    $0x8,%r15
mov    0x70(%rsp),%eax
mov    %rbp,%rdi
cmp    %rdx,%rbp
jne    16d0 <NURBSsurfaceBasisX2Max+0x5c0>
jmp    1650 <NURBSsurfaceBasisX2Max+0x540>
add    $0xb8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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