void mu_comp(double *eta, int p, int n, int order, int m, int nknots,
             double *knots, double *knotsI, double *all_beta, double *all_mu) {
  int i, j, k, supi;
  double *B, *BI;
  int *offsets, *offsetsI, *derivs;
  B = (double *)calloc(order * n * p, sizeof(double));
  BI = (double *)calloc(order * n * p, sizeof(double));
  derivs = (int *)calloc(n * p, sizeof(int));
  for (i = 0; i < n * p; i++)
    derivs[i] = 0;
  offsets = (int *)calloc(n * p, sizeof(int));
  offsetsI = (int *)calloc(n * p, sizeof(int));
  spline_basis(knotsI, (nknots - 1), order, eta, n * p, derivs, n * p, offsetsI,
               BI);
  print_matrix("BI: ", order, n, BI, n);
  for (i = 0; i < n * p; i++) {
    Rprintf("  offsetsI[%d]=%d\n", i, offsetsI[i]);
  }
  spline_basis(knots, nknots, order, eta, n * p, derivs, n * p, offsets, B);
  print_matrix("B: ", order, n, B, n);
  for (j = 0; j < p; j++) {
    for (k = 0; k <= j; k++) {
      if (k == 0) {
        for (i = 0; i < n; i++) {
          for (supi = 0; supi < order; supi++) {
            all_mu[j * (j + 1) * n / 2 + k] =
                all_mu[j * (j + 1) * n / 2 + k] +
                BI[j * order * n + i * order + supi] *
                    all_beta[j * (j + 1) * m / 2 + offsetsI[j * n + i] - 1 +
                             supi];
          }
        }
      } else {
        for (i = 0; i < n; i++) {
          if (offsets[j * n + i] != 0) {
            for (supi = 0; supi < order; supi++) {
              all_mu[j * (j + 1) * n / 2 + k * n + i] =
                  all_mu[j * (j + 1) * n / 2 + k * n + i] +
                  B[j * order * n + i * order + supi] *
                      all_beta[j * (j + 1) * m / 2 + k * m +
                               offsets[j * n + i] - 1 + supi];
            }
          } else {
            for (supi = 0; supi < (order - 1); supi++) {
              all_mu[j * (j + 1) * n / 2 + k * n + i] =
                  all_mu[j * (j + 1) * n / 2 + k * n + i] +
                  B[j * order * n + i * order + supi + 1] *
                      all_beta[j * (j + 1) * m / 2 + k * m +
                               offsets[j * n + i] + supi];
            }
          }
        }
      }
    }
  }
  free(B);
  free(BI);
  free(derivs);
  free(offsets);
  free(offsetsI);
}


x86 assembly (clang, -O0):
<mu_comp>:
push   %rbp
mov    %rsp,%rbp
sub    $0xc0,%rsp
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %ecx,-0x14(%rbp)
mov    %r8d,-0x18(%rbp)
mov    %r9d,-0x1c(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x10(%rbp),%eax
imul   -0xc(%rbp),%eax
movslq %eax,%rdi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x14(%rbp),%eax
imul   -0x10(%rbp),%eax
imul   -0xc(%rbp),%eax
movslq %eax,%rdi
mov    $0x8,%esi
call   1060 <calloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%eax
imul   -0xc(%rbp),%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,-0x58(%rbp)
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    1206 <mu_comp+0xb6>
mov    -0x58(%rbp),%rax
movslq -0x20(%rbp),%rcx
movl   $0x0,(%rax,%rcx,4)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    11d7 <mu_comp+0x87>
mov    -0x10(%rbp),%eax
imul   -0xc(%rbp),%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x10(%rbp),%eax
imul   -0xc(%rbp),%eax
movslq %eax,%rdi
mov    $0x4,%esi
call   1060 <calloc@plt>
mov    %rax,-0x50(%rbp)
mov    0x18(%rbp),%rdi
mov    -0x1c(%rbp),%esi
sub    $0x1,%esi
mov    -0x14(%rbp),%edx
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%r8d
imul   -0xc(%rbp),%r8d
mov    -0x58(%rbp),%r9
mov    -0x10(%rbp),%r11d
imul   -0xc(%rbp),%r11d
mov    -0x50(%rbp),%r10
mov    -0x40(%rbp),%rax
mov    %r11d,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
mov    $0x0,%al
call   1040 <spline_basis@plt>
mov    -0x14(%rbp),%esi
mov    -0x10(%rbp),%edx
mov    -0x40(%rbp),%rcx
mov    -0x10(%rbp),%r8d
lea    0xd71(%rip),%rdi
mov    $0x0,%al
call   1070 <print_matrix@plt>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
mov    -0x10(%rbp),%ecx
imul   -0xc(%rbp),%ecx
cmp    %ecx,%eax
jge    12d9 <mu_comp+0x189>
mov    -0x20(%rbp),%esi
mov    -0x50(%rbp),%rax
movslq -0x20(%rbp),%rcx
mov    (%rax,%rcx,4),%edx
lea    0xd41(%rip),%rdi
mov    $0x0,%al
call   1050 <Rprintf@plt>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    129d <mu_comp+0x14d>
mov    0x10(%rbp),%rdi
mov    -0x1c(%rbp),%esi
mov    -0x14(%rbp),%edx
mov    -0x8(%rbp),%rcx
mov    -0x10(%rbp),%r8d
imul   -0xc(%rbp),%r8d
mov    -0x58(%rbp),%r9
mov    -0x10(%rbp),%r11d
imul   -0xc(%rbp),%r11d
mov    -0x48(%rbp),%r10
mov    -0x38(%rbp),%rax
mov    %r11d,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
mov    $0x0,%al
call   1040 <spline_basis@plt>
mov    -0x14(%rbp),%esi
mov    -0x10(%rbp),%edx
mov    -0x38(%rbp),%rcx
mov    -0x10(%rbp),%r8d
lea    0xce9(%rip),%rdi
mov    $0x0,%al
call   1070 <print_matrix@plt>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    173c <mu_comp+0x5ec>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x24(%rbp),%eax
jg     1729 <mu_comp+0x5d9>
cmpl   $0x0,-0x28(%rbp)
jne    1487 <mu_comp+0x337>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1482 <mu_comp+0x332>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    146f <mu_comp+0x31f>
mov    0x28(%rbp),%rax
mov    %rax,-0x70(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
imul   -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x70(%rbp),%rax
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x40(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x10(%rbp),%ecx
mov    -0x20(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
imul   -0x18(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x68(%rbp),%rax
mov    -0x50(%rbp),%rdx
mov    -0x24(%rbp),%esi
imul   -0x10(%rbp),%esi
add    -0x20(%rbp),%esi
movslq %esi,%rsi
add    (%rdx,%rsi,4),%ecx
sub    $0x1,%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
imul   -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x60(%rbp),%rax
add    -0x28(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1380 <mu_comp+0x230>
jmp    1474 <mu_comp+0x324>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    136d <mu_comp+0x21d>
jmp    1716 <mu_comp+0x5c6>
movl   $0x0,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x10(%rbp),%eax
jge    1711 <mu_comp+0x5c1>
mov    -0x48(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x10(%rbp),%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     15d1 <mu_comp+0x481>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x14(%rbp),%eax
jge    15cc <mu_comp+0x47c>
mov    0x28(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
imul   -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x88(%rbp),%rax
mov    -0x28(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x10(%rbp),%ecx
mov    -0x20(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    %rax,-0x80(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
imul   -0x18(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x80(%rbp),%rax
mov    -0x28(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
mov    -0x48(%rbp),%rdx
mov    -0x24(%rbp),%esi
imul   -0x10(%rbp),%esi
add    -0x20(%rbp),%esi
movslq %esi,%rsi
add    (%rdx,%rsi,4),%ecx
sub    $0x1,%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
mov    %rax,-0x78(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
imul   -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x78(%rbp),%rax
mov    -0x28(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    14bc <mu_comp+0x36c>
jmp    16fe <mu_comp+0x5ae>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x14(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jge    16f9 <mu_comp+0x5a9>
mov    0x28(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
imul   -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0xa0(%rbp),%rax
mov    -0x28(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x38(%rbp),%rax
mov    -0x24(%rbp),%ecx
imul   -0x14(%rbp),%ecx
imul   -0x10(%rbp),%ecx
mov    -0x20(%rbp),%edx
imul   -0x14(%rbp),%edx
add    %edx,%ecx
add    -0x2c(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x20(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
imul   -0x18(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x98(%rbp),%rax
mov    -0x28(%rbp),%edx
imul   -0x18(%rbp),%edx
add    %edx,%ecx
mov    -0x48(%rbp),%rdx
mov    -0x24(%rbp),%esi
imul   -0x10(%rbp),%esi
add    -0x20(%rbp),%esi
movslq %esi,%rsi
add    (%rdx,%rsi,4),%ecx
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    0x28(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x24(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
imul   -0x10(%rbp),%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x90(%rbp),%rax
mov    -0x28(%rbp),%edx
imul   -0x10(%rbp),%edx
add    %edx,%ecx
add    -0x20(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15d8 <mu_comp+0x488>
jmp    16fe <mu_comp+0x5ae>
jmp    1703 <mu_comp+0x5b3>
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    148e <mu_comp+0x33e>
jmp    1716 <mu_comp+0x5c6>
jmp    171b <mu_comp+0x5cb>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1350 <mu_comp+0x200>
jmp    172e <mu_comp+0x5de>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    133d <mu_comp+0x1ed>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
add    $0xc0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mu_comp>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xe8,%rsp
mov    %r9,0x40(%rsp)
mov    %r8d,0x14(%rsp)
mov    %rcx,0x38(%rsp)
mov    %edx,%r13d
mov    %esi,%r12d
mov    %rdi,0x8(%rsp)
mov    0x138(%rsp),%r15
mov    0x130(%rsp),%r14
mov    0x120(%rsp),%rax
mov    %rax,0x48(%rsp)
mov    0x128(%rsp),%rax
mov    %rax,0x20(%rsp)
mov    %ecx,%eax
imul   %edx,%eax
mov    %edx,(%rsp)
mov    %eax,0x60(%rsp)
imul   %esi,%eax
movslq %eax,%rbx
mov    $0x8,%esi
mov    %rbx,%rdi
call   1060 <calloc@plt>
mov    %rax,%rbp
mov    $0x8,%esi
mov    %rbx,%rdi
call   1060 <calloc@plt>
mov    %rax,0x28(%rsp)
mov    %r13d,%eax
mov    %r12d,0x50(%rsp)
imul   %r12d,%eax
mov    %rax,0x30(%rsp)
movslq %eax,%r13
mov    $0x4,%esi
mov    %r13,%rdi
call   1060 <calloc@plt>
mov    %rax,%r12
mov    $0x4,%esi
mov    %r13,%rdi
call   1060 <calloc@plt>
mov    %rax,0x58(%rsp)
mov    $0x4,%esi
mov    %r13,%rdi
call   1060 <calloc@plt>
mov    0x40(%rsp),%rcx
lea    -0x1(%rcx),%esi
sub    $0x8,%rsp
mov    0x28(%rsp),%rdi
mov    0x40(%rsp),%rbx
mov    %ebx,%edx
mov    0x10(%rsp),%rcx
mov    %r13,%r8
mov    %r13,0x20(%rsp)
mov    %r12,0x70(%rsp)
mov    %r12,%r9
mov    %rax,%r12
xor    %eax,%eax
mov    0x30(%rsp),%r13
push   %r13
push   %r12
push   %r8
call   1040 <spline_basis@plt>
add    $0x20,%rsp
lea    0xd97(%rip),%rdi
mov    %ebx,%esi
mov    (%rsp),%edx
mov    %r13,%rcx
mov    %edx,%r8d
xor    %eax,%eax
call   1070 <print_matrix@plt>
cmpl   $0x0,0x18(%rsp)
jle    12ae <mu_comp+0x15e>
mov    0x30(%rsp),%ebx
xor    %r13d,%r13d
nopl   0x0(%rax)
mov    (%r12,%r13,4),%edx
lea    0xd6a(%rip),%rdi
mov    %r13d,%esi
xor    %eax,%eax
call   1050 <Rprintf@plt>
add    $0x1,%r13
cmp    %r13,%rbx
jne    1290 <mu_comp+0x140>
mov    %r12,0x98(%rsp)
sub    $0x8,%rsp
mov    0x50(%rsp),%rdi
mov    0x48(%rsp),%rsi
mov    0x40(%rsp),%rbx
mov    %ebx,%edx
mov    0x10(%rsp),%rcx
mov    0x38(%rsp),%r8
mov    0x70(%rsp),%r9
xor    %eax,%eax
push   %rbp
push   0x68(%rsp)
push   %r8
call   1040 <spline_basis@plt>
add    $0x20,%rsp
lea    0xd25(%rip),%rdi
mov    %ebx,%esi
mov    (%rsp),%edx
mov    %rbp,%rcx
mov    %edx,%r8d
xor    %eax,%eax
call   1070 <print_matrix@plt>
mov    0x50(%rsp),%esi
test   %esi,%esi
mov    0x28(%rsp),%r12
jle    17e6 <mu_comp+0x696>
lea    -0x1(%rbx),%ecx
mov    (%rsp),%eax
movslq %eax,%rdx
mov    %rdx,0x70(%rsp)
movslq 0x14(%rsp),%rdx
mov    %esi,%esi
mov    %rsi,0xa8(%rsp)
mov    %eax,%esi
mov    %ebx,%r8d
lea    -0x1(%r8),%rax
mov    %rax,0x50(%rsp)
mov    %r8,0x30(%rsp)
and    $0xfffffffe,%r8d
mov    %rcx,0x90(%rsp)
and    $0xfffffffe,%ecx
mov    %rcx,0xd0(%rsp)
lea    0x8(%r14),%rax
mov    %rax,0xa0(%rsp)
mov    %rdx,0xb8(%rsp)
lea    0x0(,%rdx,8),%rax
mov    %rax,0xc8(%rsp)
mov    $0x1,%eax
mov    %rax,0x78(%rsp)
movl   $0x1,0x4(%rsp)
xor    %eax,%eax
mov    %rsi,0x8(%rsp)
jmp    13c8 <mu_comp+0x278>
nopl   0x0(%rax)
addq   $0x1,0x78(%rsp)
mov    0x4(%rsp),%eax
add    0x60(%rsp),%eax
mov    %eax,0x4(%rsp)
mov    0xb0(%rsp),%rax
cmp    0xa8(%rsp),%rax
je     17e6 <mu_comp+0x696>
mov    %rsi,%r9
mov    %eax,%esi
mov    %rax,%rcx
imul   0x70(%rsp),%rcx
mov    %rcx,0x40(%rsp)
add    $0x1,%rax
mov    %rax,0xb0(%rsp)
imul   %esi,%eax
mov    %eax,%ecx
mov    (%rsp),%edi
imul   %edi,%ecx
mov    %ecx,%edx
shr    $0x1f,%edx
add    %ecx,%edx
sar    %edx
imul   %edi,%esi
mov    %rsi,0x20(%rsp)
mov    %r9,%rsi
imul   0x14(%rsp),%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
lea    -0x1(%rcx),%eax
mov    %rax,0x88(%rsp)
movslq %edx,%r9
movslq %ecx,%rdx
mov    0xa0(%rsp),%rax
mov    %rdx,0xc0(%rsp)
lea    (%rax,%rdx,8),%r11
mov    %rcx,0xe0(%rsp)
mov    %rcx,0x18(%rsp)
xor    %ecx,%ecx
jmp    1482 <mu_comp+0x332>
nopw   0x0(%rax,%rax,1)
mov    0x80(%rsp),%rcx
add    $0x1,%rcx
mov    0x18(%rsp),%rax
add    0x14(%rsp),%eax
mov    %rax,0x18(%rsp)
add    0xc8(%rsp),%r11
cmp    0x78(%rsp),%rcx
mov    0x28(%rsp),%r12
je     13a0 <mu_comp+0x250>
test   %rcx,%rcx
mov    %rcx,0x80(%rsp)
je     16d0 <mu_comp+0x580>
cmpl   $0x0,(%rsp)
jle    1450 <mu_comp+0x300>
mov    0x80(%rsp),%rax
mov    %rax,%rcx
imul   0x70(%rsp),%rcx
add    %r9,%rcx
mov    %rcx,0x48(%rsp)
mov    %rax,%rcx
imul   0xb8(%rsp),%rcx
mov    0x88(%rsp),%rax
add    %ecx,%eax
mov    %eax,0x64(%rsp)
add    0xc0(%rsp),%rcx
mov    %rcx,0xd8(%rsp)
mov    0x4(%rsp),%r13d
xor    %ecx,%ecx
jmp    1510 <mu_comp+0x3c0>
cs nopw 0x0(%rax,%rax,1)
nop
mulsd  (%r14,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rdx,8)
add    $0x1,%rcx
add    %ebx,%r13d
cmp    %rsi,%rcx
je     1450 <mu_comp+0x300>
mov    0x40(%rsp),%rax
add    %rcx,%rax
mov    0x58(%rsp),%rdx
mov    (%rdx,%rax,4),%r10d
test   %r10d,%r10d
je     15c0 <mu_comp+0x470>
test   %ebx,%ebx
jle    1500 <mu_comp+0x3b0>
mov    0x48(%rsp),%rax
lea    (%rax,%rcx,1),%rdx
movsd  (%r15,%rdx,8),%xmm0
cmpq   $0x0,0x50(%rsp)
je     15e9 <mu_comp+0x499>
mov    0x18(%rsp),%rax
lea    (%rax,%r10,1),%edi
mov    %r13d,%r12d
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
lea    -0x1(%r12),%ebx
movslq %ebx,%rbx
movsd  0x0(%rbp,%rbx,8),%xmm1
lea    -0x1(%rdi),%ebx
movslq %ebx,%rbx
mulsd  (%r14,%rbx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rdx,8)
movslq %r12d,%r12
movsd  0x0(%rbp,%r12,8),%xmm0
movslq %edi,%rdi
mulsd  (%r14,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r15,%rdx,8)
add    $0x2,%rax
add    $0x2,%r12d
add    $0x2,%edi
cmp    %rax,%r8
jne    1560 <mu_comp+0x410>
jmp    15eb <mu_comp+0x49b>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    $0x2,%ebx
jl     1500 <mu_comp+0x3b0>
mov    0x48(%rsp),%rax
lea    (%rax,%rcx,1),%rdx
movsd  (%r15,%rdx,8),%xmm0
cmpl   $0x1,0x90(%rsp)
01
jne    1626 <mu_comp+0x4d6>
xor    %eax,%eax
jmp    1682 <mu_comp+0x532>
xor    %eax,%eax
testb  $0x1,0x30(%rsp)
mov    0x38(%rsp),%rbx
je     1500 <mu_comp+0x3b0>
mov    0x20(%rsp),%rsi
lea    (%rsi,%rcx,1),%edi
mov    0x8(%rsp),%rsi
imul   %ebx,%edi
add    0x64(%rsp),%r10d
add    %eax,%edi
movslq %edi,%rdi
movsd  0x0(%rbp,%rdi,8),%xmm1
add    %eax,%r10d
movslq %r10d,%rax
jmp    14f0 <mu_comp+0x3a0>
mov    %r13d,%edi
xor    %eax,%eax
mov    0xd0(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movslq %edi,%rdi
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  -0x8(%r11,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%rdx,8)
lea    0x1(%rdi),%ebx
movslq %ebx,%rbx
movsd  0x0(%rbp,%rbx,8),%xmm0
mulsd  (%r11,%rax,8),%xmm0
add    $0x2,%rax
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r15,%rdx,8)
add    $0x2,%edi
cmp    %rax,%rsi
jne    1640 <mu_comp+0x4f0>
testb  $0x1,0x90(%rsp)
01
mov    0x38(%rsp),%rbx
mov    0x8(%rsp),%rsi
je     1500 <mu_comp+0x3b0>
mov    0x20(%rsp),%rsi
lea    (%rsi,%rcx,1),%edi
mov    0x8(%rsp),%rsi
imul   %ebx,%edi
add    %eax,%edi
add    $0x1,%edi
movslq %edi,%rdi
movsd  0x0(%rbp,%rdi,8),%xmm1
add    0xd8(%rsp),%rax
jmp    14f0 <mu_comp+0x3a0>
cs nopw 0x0(%rax,%rax,1)
nop
cmpl   $0x0,(%rsp)
jle    1450 <mu_comp+0x300>
mov    0x4(%rsp),%r12d
xor    %edx,%edx
jmp    1700 <mu_comp+0x5b0>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
add    $0x1,%rdx
add    %ebx,%r12d
cmp    %rsi,%rdx
je     1450 <mu_comp+0x300>
test   %ebx,%ebx
jle    16f0 <mu_comp+0x5a0>
mov    0x40(%rsp),%rax
add    %rdx,%rax
mov    0x98(%rsp),%rcx
mov    (%rcx,%rax,4),%r10d
movsd  (%r15,%r9,8),%xmm0
cmpq   $0x0,0x50(%rsp)
je     1790 <mu_comp+0x640>
mov    0xe0(%rsp),%rax
lea    (%rax,%r10,1),%edi
mov    %r12d,%ebx
xor    %eax,%eax
mov    0x28(%rsp),%rsi
nopl   0x0(%rax)
lea    -0x1(%rbx),%ecx
movslq %ecx,%rcx
movsd  (%rsi,%rcx,8),%xmm1
lea    -0x1(%rdi),%ecx
movslq %ecx,%rcx
mulsd  (%r14,%rcx,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%r9,8)
movslq %ebx,%rbx
movsd  (%rsi,%rbx,8),%xmm0
movslq %edi,%rdi
mulsd  (%r14,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%r15,%r9,8)
add    $0x2,%rax
add    $0x2,%ebx
add    $0x2,%edi
cmp    %rax,%r8
jne    1740 <mu_comp+0x5f0>
jmp    1792 <mu_comp+0x642>
nopl   (%rax)
xor    %eax,%eax
testb  $0x1,0x30(%rsp)
mov    0x38(%rsp),%rbx
mov    0x8(%rsp),%rsi
je     16f0 <mu_comp+0x5a0>
mov    0x20(%rsp),%rcx
add    %edx,%ecx
imul   %ebx,%ecx
add    %eax,%ecx
movslq %ecx,%rcx
mov    0x28(%rsp),%rsi
movsd  (%rsi,%rcx,8),%xmm1
mov    0x8(%rsp),%rsi
add    0x88(%rsp),%eax
add    %r10d,%eax
cltq
mulsd  (%r14,%rax,8),%xmm1
addsd  %xmm0,%xmm1
movsd  %xmm1,(%r15,%r9,8)
jmp    16f0 <mu_comp+0x5a0>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %r12,%rdi
call   1030 <free@plt>
mov    0x68(%rsp),%rdi
call   1030 <free@plt>
mov    0x58(%rsp),%rdi
call   1030 <free@plt>
mov    0x98(%rsp),%rdi
add    $0xe8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
jmp    1030 <free@plt>

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

LLVM IR (-O2):
@.str = [5 x i8] c"BI: \00"
@.str.1 = [19 x i8] c" offsetsI[%d]=%d\0A\00"
@.str.2 = [4 x i8] c"B: \00"
define void @mu_comp(double* %0, i32 %1, i32 %2, i32 %3, i32 %4, i32 %5, double* %6, double* %7, double* nocapture %8, double* nocapture %9) {
%11 = mul nsw i32 %3, %2
%12 = mul nsw i32 %11, %1
%13 = sext i32 %12 to i64
%14 = tail call i8* @calloc(i64 %13, i64 8)
%15 = bitcast i8* %14 to double*
%16 = tail call i8* @calloc(i64 %13, i64 8)
%17 = bitcast i8* %16 to double*
%18 = mul nsw i32 %2, %1
%19 = sext i32 %18 to i64
%20 = tail call i8* @calloc(i64 %19, i64 4)
%21 = bitcast i8* %20 to i32*
%22 = icmp sgt i32 %18, 0
%23 = tail call i8* @calloc(i64 %19, i64 4)
%24 = bitcast i8* %23 to i32*
%25 = tail call i8* @calloc(i64 %19, i64 4)
%26 = bitcast i8* %25 to i32*
%27 = add nsw i32 %5, -1
%28 = tail call i32 (double*, i32, i32, double*, i32, i32*, i32, i32*, double*, ...) bitcast (i32 (...)* @spline_basis to i32 (double*, i32, i32, double*, i32, i32*, i32, i32*, double*, ...)*)(double* %7, i32 %27, i32 %3, double* %0, i32 %18, i32* %21, i32 %18, i32* %26, double* %17)
%29 = tail call i32 (i8*, i32, i32, double*, i32, ...) bitcast (i32 (...)* @print_matrix to i32 (i8*, i32, i32, double*, i32, ...)*)(i8* getelementptr inbounds ([5 x i8], [5 x i8]* @.str, i64 0, i64 0), i32 %3, i32 %2, double* %17, i32 %2)
br i1 %22, label %30, label %40
30: ; preds = %10
%31 = zext i32 %18 to i64
br label %32
32: ; preds = %30, %32
%33 = phi i64 [ 0, %30 ], [ %38, %32 ]
%34 = getelementptr inbounds i32, i32* %26, i64 %33
%35 = load i32, i32* %34
%36 = trunc i64 %33 to i32
%37 = tail call i32 (i8*, i32, i32, ...) bitcast (i32 (...)* @Rprintf to i32 (i8*, i32, i32, ...)*)(i8* getelementptr inbounds ([19 x i8], [19 x i8]* @.str.1, i64 0, i64 0), i32 %36, i32 %35)
%38 = add nuw nsw i64 %33, 1
%39 = icmp eq i64 %38, %31
br i1 %39, label %40, label %32
40: ; preds = %32, %10
%41 = tail call i32 (double*, i32, i32, double*, i32, i32*, i32, i32*, double*, ...) bitcast (i32 (...)* @spline_basis to i32 (double*, i32, i32, double*, i32, i32*, i32, i32*, double*, ...)*)(double* %6, i32 %5, i32 %3, double* %0, i32 %18, i32* %21, i32 %18, i32* %24, double* %15)
%42 = tail call i32 (i8*, i32, i32, double*, i32, ...) bitcast (i32 (...)* @print_matrix to i32 (i8*, i32, i32, double*, i32, ...)*)(i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str.2, i64 0, i64 0), i32 %3, i32 %2, double* %15, i32 %2)
%43 = icmp sgt i32 %1, 0
br i1 %43, label %44, label %273
44: ; preds = %40
%45 = icmp sgt i32 %2, 0
%46 = icmp sgt i32 %3, 0
%47 = add i32 %3, -1
%48 = icmp sgt i32 %3, 1
%49 = sext i32 %2 to i64
%50 = sext i32 %4 to i64
%51 = zext i32 %1 to i64
%52 = zext i32 %2 to i64
%53 = zext i32 %3 to i64
%54 = zext i32 %47 to i64
%55 = zext i32 %2 to i64
%56 = add nsw i64 %53, -1
%57 = and i64 %53, 1
%58 = icmp eq i64 %56, 0
%59 = and i64 %53, 4294967294
%60 = icmp eq i64 %57, 0
%61 = and i64 %54, 1
%62 = icmp eq i32 %47, 1
%63 = and i64 %54, 4294967294
%64 = icmp eq i64 %61, 0
%65 = and i64 %53, 1
%66 = icmp eq i64 %56, 0
%67 = and i64 %53, 4294967294
%68 = icmp eq i64 %65, 0
br label %69
69: ; preds = %44, %270
%70 = phi i64 [ 0, %44 ], [ %74, %270 ]
%71 = phi i64 [ 1, %44 ], [ %271, %270 ]
%72 = trunc i64 %70 to i32
%73 = mul nsw i64 %70, %49
%74 = add nuw nsw i64 %70, 1
%75 = add nuw i64 %70, 1
%76 = and i64 %75, 4294967295
%77 = mul i64 %76, %70
%78 = trunc i64 %77 to i32
%79 = mul i32 %78, %2
%80 = sdiv i32 %79, 2
%81 = mul i32 %72, %2
%82 = trunc i64 %77 to i32
%83 = mul i32 %82, %4
%84 = sdiv i32 %83, 2
%85 = add nsw i32 %84, -1
%86 = sext i32 %80 to i64
%87 = getelementptr inbounds double, double* %9, i64 %86
%88 = sext i32 %84 to i64
br label %89
89: ; preds = %69, %267
%90 = phi i64 [ 0, %69 ], [ %268, %267 ]
%91 = icmp eq i64 %90, 0
br i1 %91, label %100, label %92
92: ; preds = %89
br i1 %45, label %93, label %267
93: ; preds = %92
%94 = mul nsw i64 %90, %49
%95 = add nsw i64 %94, %86
%96 = mul nsw i64 %90, %50
%97 = trunc i64 %96 to i32
%98 = add i32 %85, %97
%99 = add nsw i64 %96, %88
br label %159
100: ; preds = %89
br i1 %45, label %101, label %267
101: ; preds = %100, %156
%102 = phi i64 [ %157, %156 ], [ 0, %100 ]
br i1 %46, label %103, label %156
103: ; preds = %101
%104 = trunc i64 %102 to i32
%105 = add i32 %81, %104
%106 = mul i32 %105, %3
%107 = add nsw i64 %102, %73
%108 = getelementptr inbounds i32, i32* %26, i64 %107
%109 = load i32, i32* %108
%110 = load double, double* %87
br i1 %66, label %141, label %111
111: ; preds = %103, %111
%112 = phi double [ %137, %111 ], [ %110, %103 ]
%113 = phi i64 [ %138, %111 ], [ 0, %103 ]
%114 = phi i64 [ %139, %111 ], [ 0, %103 ]
%115 = trunc i64 %113 to i32
%116 = add i32 %106, %115
%117 = sext i32 %116 to i64
%118 = getelementptr inbounds double, double* %17, i64 %117
%119 = load double, double* %118
%120 = add i32 %85, %115
%121 = add i32 %120, %109
%122 = sext i32 %121 to i64
%123 = getelementptr inbounds double, double* %8, i64 %122
%124 = load double, double* %123
%125 = tail call double @llvm.fmuladd.f64(double %119, double %124, double %112)
store double %125, double* %87
%126 = trunc i64 %113 to i32
%127 = or i32 %126, 1
%128 = add i32 %106, %127
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds double, double* %17, i64 %129
%131 = load double, double* %130
%132 = add i32 %85, %127
%133 = add i32 %132, %109
%134 = sext i32 %133 to i64
%135 = getelementptr inbounds double, double* %8, i64 %134
%136 = load double, double* %135
%137 = tail call double @llvm.fmuladd.f64(double %131, double %136, double %125)
store double %137, double* %87
%138 = add nuw nsw i64 %113, 2
%139 = add i64 %114, 2
%140 = icmp eq i64 %139, %67
br i1 %140, label %141, label %111
141: ; preds = %111, %103
%142 = phi double [ %110, %103 ], [ %137, %111 ]
%143 = phi i64 [ 0, %103 ], [ %138, %111 ]
br i1 %68, label %156, label %144
144: ; preds = %141
%145 = trunc i64 %143 to i32
%146 = add i32 %106, %145
%147 = sext i32 %146 to i64
%148 = getelementptr inbounds double, double* %17, i64 %147
%149 = load double, double* %148
%150 = add i32 %85, %145
%151 = add i32 %150, %109
%152 = sext i32 %151 to i64
%153 = getelementptr inbounds double, double* %8, i64 %152
%154 = load double, double* %153
%155 = tail call double @llvm.fmuladd.f64(double %149, double %154, double %142)
store double %155, double* %87
br label %156
156: ; preds = %144, %141, %101
%157 = add nuw nsw i64 %102, 1
%158 = icmp eq i64 %157, %55
br i1 %158, label %267, label %101
159: ; preds = %93, %264
%160 = phi i64 [ 0, %93 ], [ %265, %264 ]
%161 = add nsw i64 %160, %73
%162 = getelementptr inbounds i32, i32* %24, i64 %161
%163 = load i32, i32* %162
%164 = icmp eq i32 %163, 0
br i1 %164, label %174, label %165
165: ; preds = %159
br i1 %46, label %166, label %264
166: ; preds = %165
%167 = add nsw i64 %95, %160
%168 = getelementptr inbounds double, double* %9, i64 %167
%169 = trunc i64 %160 to i32
%170 = add i32 %81, %169
%171 = mul i32 %170, %3
%172 = add i32 %98, %163
%173 = load double, double* %168
br i1 %58, label %250, label %182
174: ; preds = %159
br i1 %48, label %175, label %264
175: ; preds = %174
%176 = add nsw i64 %95, %160
%177 = getelementptr inbounds double, double* %9, i64 %176
%178 = trunc i64 %160 to i32
%179 = add i32 %81, %178
%180 = mul i32 %179, %3
%181 = load double, double* %177
br i1 %62, label %236, label %210
182: ; preds = %166, %182
%183 = phi double [ %206, %182 ], [ %173, %166 ]
%184 = phi i64 [ %207, %182 ], [ 0, %166 ]
%185 = phi i64 [ %208, %182 ], [ 0, %166 ]
%186 = trunc i64 %184 to i32
%187 = add i32 %171, %186
%188 = sext i32 %187 to i64
%189 = getelementptr inbounds double, double* %15, i64 %188
%190 = load double, double* %189
%191 = add i32 %172, %186
%192 = sext i32 %191 to i64
%193 = getelementptr inbounds double, double* %8, i64 %192
%194 = load double, double* %193
%195 = tail call double @llvm.fmuladd.f64(double %190, double %194, double %183)
store double %195, double* %168
%196 = trunc i64 %184 to i32
%197 = or i32 %196, 1
%198 = add i32 %171, %197
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds double, double* %15, i64 %199
%201 = load double, double* %200
%202 = add i32 %172, %197
%203 = sext i32 %202 to i64
%204 = getelementptr inbounds double, double* %8, i64 %203
%205 = load double, double* %204
%206 = tail call double @llvm.fmuladd.f64(double %201, double %205, double %195)
store double %206, double* %168
%207 = add nuw nsw i64 %184, 2
%208 = add i64 %185, 2
%209 = icmp eq i64 %208, %59
br i1 %209, label %250, label %182
210: ; preds = %175, %210
%211 = phi double [ %233, %210 ], [ %181, %175 ]
%212 = phi i64 [ %224, %210 ], [ 0, %175 ]
%213 = phi i64 [ %234, %210 ], [ 0, %175 ]
%214 = or i64 %212, 1
%215 = trunc i64 %214 to i32
%216 = add i32 %180, %215
%217 = sext i32 %216 to i64
%218 = getelementptr inbounds double, double* %15, i64 %217
%219 = load double, double* %218
%220 = add nsw i64 %99, %212
%221 = getelementptr inbounds double, double* %8, i64 %220
%222 = load double, double* %221
%223 = tail call double @llvm.fmuladd.f64(double %219, double %222, double %211)
store double %223, double* %177
%224 = add nuw nsw i64 %212, 2
%225 = trunc i64 %224 to i32
%226 = add i32 %180, %225
%227 = sext i32 %226 to i64
%228 = getelementptr inbounds double, double* %15, i64 %227
%229 = load double, double* %228
%230 = add nsw i64 %99, %214
%231 = getelementptr inbounds double, double* %8, i64 %230
%232 = load double, double* %231
%233 = tail call double @llvm.fmuladd.f64(double %229, double %232, double %223)
store double %233, double* %177
%234 = add i64 %213, 2
%235 = icmp eq i64 %234, %63
br i1 %235, label %236, label %210
236: ; preds = %210, %175
%237 = phi double [ %181, %175 ], [ %233, %210 ]
%238 = phi i64 [ 0, %175 ], [ %224, %210 ]
br i1 %64, label %264, label %239
239: ; preds = %236
%240 = trunc i64 %238 to i32
%241 = add i32 %240, 1
%242 = add i32 %180, %241
%243 = sext i32 %242 to i64
%244 = getelementptr inbounds double, double* %15, i64 %243
%245 = load double, double* %244
%246 = add nsw i64 %99, %238
%247 = getelementptr inbounds double, double* %8, i64 %246
%248 = load double, double* %247
%249 = tail call double @llvm.fmuladd.f64(double %245, double %248, double %237)
store double %249, double* %177
br label %264
250: ; preds = %182, %166
%251 = phi double [ %173, %166 ], [ %206, %182 ]
%252 = phi i64 [ 0, %166 ], [ %207, %182 ]
br i1 %60, label %264, label %253
253: ; preds = %250
%254 = trunc i64 %252 to i32
%255 = add i32 %171, %254
%256 = sext i32 %255 to i64
%257 = getelementptr inbounds double, double* %15, i64 %256
%258 = load double, double* %257
%259 = add i32 %172, %254
%260 = sext i32 %259 to i64
%261 = getelementptr inbounds double, double* %8, i64 %260
%262 = load double, double* %261
%263 = tail call double @llvm.fmuladd.f64(double %258, double %262, double %251)
store double %263, double* %168
br label %264
264: ; preds = %253, %250, %239, %236, %165, %174
%265 = add nuw nsw i64 %160, 1
%266 = icmp eq i64 %265, %52
br i1 %266, label %267, label %159
267: ; preds = %264, %156, %92, %100
%268 = add nuw nsw i64 %90, 1
%269 = icmp eq i64 %268, %71
br i1 %269, label %270, label %89
270: ; preds = %267
%271 = add nuw nsw i64 %71, 1
%272 = icmp eq i64 %74, %51
br i1 %272, label %273, label %69
273: ; preds = %270, %40
tail call void @free(i8* %14)
tail call void @free(i8* %16)
tail call void @free(i8* %20)
tail call void @free(i8* %23)
tail call void @free(i8* %25)
ret void
}