void mu_B_fct(int n, int p, int order, int m, int nknots, double *knots,
              double *knotsI, double *all_beta, double *eta, double *Ball_mat,
              double *mu) {
  int i, j, k, supi, l;
  double *B, *BI, *Ball, *all_mu, *mu_p, *etai;
  int *offsets, *offsetsI, *derivs;
  for (i = 0; i < n; i++) {
    Ball = (double *)calloc(m * p, sizeof(double));
    all_mu = (double *)calloc(p * (p + 1) / 2, sizeof(double));
    B = (double *)calloc(order * p, sizeof(double));
    BI = (double *)calloc(order * p, sizeof(double));
    mu_p = (double *)calloc(p, sizeof(double));
    etai = (double *)calloc(p, sizeof(double));
    derivs = (int *)calloc(p, sizeof(int));
    offsets = (int *)calloc(p, sizeof(int));
    offsetsI = (int *)calloc(p, sizeof(int));
    for (k = 0; k < p; k++)
      etai[k] = eta[k * n + i];
    spline_basis(knotsI, (nknots - 1), order, etai, p, derivs, p, offsetsI, BI);
    spline_basis(knots, nknots, order, etai, p, derivs, p, offsets, B);
    for (l = 0; l < order; l++) {
      Ball[offsetsI[0] + l] = BI[l];
    }
    for (j = 1; j < p; j++) {
      if (offsets[j] != 0) {
        for (l = 0; l < order; l++) {
          Ball[m * j + offsets[j] + l - 1] = B[j * order + l];
        }
      } else {
        for (l = 1; l < order; l++) {
          Ball[m * j + offsets[j] + l - 1] = B[j * order + l];
        }
      }
    }
    for (j = 0; j < p; j++) {
      for (k = 0; k <= j; k++) {
        for (supi = k * m; supi < (k + 1) * m; supi++)
          all_mu[j * (j + 1) / 2 + k] +=
              Ball[supi] * all_beta[j * (j + 1) * m / 2 + supi];
      }
    }
    for (j = 0; j < p; j++) {
      for (k = 0; k < j + 1; k++) {
        mu_p[j] = mu_p[j] + all_mu[j * (j + 1) / 2 + k];
      }
    }
    for (k = 0; k < p; k++)
      mu[k * n + i] = mu_p[k];
    for (k = 0; k < m * p; k++)
      Ball_mat[k * n + i] = Ball[k];
    free(Ball);
    free(all_mu);
    free(mu_p);
    free(B);
    free(BI);
    free(etai);
    free(offsets);
    free(offsetsI);
    free(derivs);
  }
}


x86 assembly (clang, -O0):
<mu_B_fct>:
push   %rbp
mov    %rsp,%rbp
sub    $0xb0,%rsp
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %edi,-0x4(%rbp)
mov    %esi,-0x8(%rbp)
mov    %edx,-0xc(%rbp)
mov    %ecx,-0x10(%rbp)
mov    %r8d,-0x14(%rbp)
mov    %r9,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x4(%rbp),%eax
jge    16b0 <mu_B_fct+0x580>
mov    -0x10(%rbp),%eax
imul   -0x8(%rbp),%eax
movslq %eax,%rdi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x8(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
movslq %eax,%rdi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x58(%rbp)
mov    -0xc(%rbp),%eax
imul   -0x8(%rbp),%eax
movslq %eax,%rdi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0xc(%rbp),%eax
imul   -0x8(%rbp),%eax
movslq %eax,%rdi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x48(%rbp)
movslq -0x8(%rbp),%rdi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x60(%rbp)
movslq -0x8(%rbp),%rdi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x68(%rbp)
movslq -0x8(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x80(%rbp)
movslq -0x8(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x70(%rbp)
movslq -0x8(%rbp),%rdi
mov    $0x4,%esi
call   1050 <calloc@plt>
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1281 <mu_B_fct+0x151>
mov    0x20(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x68(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1244 <mu_B_fct+0x114>
mov    0x10(%rbp),%rdi
mov    -0x14(%rbp),%esi
sub    $0x1,%esi
mov    -0xc(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    -0x8(%rbp),%r8d
mov    -0x80(%rbp),%r9
mov    -0x8(%rbp),%r11d
mov    -0x78(%rbp),%r10
mov    -0x48(%rbp),%rax
mov    %r11d,(%rsp)
mov    %r10,0x8(%rsp)
mov    %rax,0x10(%rsp)
mov    $0x0,%al
call   1040 <spline_basis@plt>
mov    -0x20(%rbp),%rdi
mov    -0x14(%rbp),%esi
mov    -0xc(%rbp),%edx
mov    -0x68(%rbp),%rcx
mov    -0x8(%rbp),%r8d
mov    -0x80(%rbp),%r9
mov    -0x8(%rbp),%r11d
mov    -0x70(%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>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1335 <mu_B_fct+0x205>
mov    -0x48(%rbp),%rax
movslq -0x34(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x78(%rbp),%rcx
mov    (%rcx),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    12f9 <mu_B_fct+0x1c9>
movl   $0x1,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    142d <mu_B_fct+0x2fd>
mov    -0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
cmpl   $0x0,(%rax,%rcx,4)
je     13ba <mu_B_fct+0x28a>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    13b5 <mu_B_fct+0x285>
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0x28(%rbp),%ecx
mov    -0x70(%rbp),%rdx
movslq -0x28(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
add    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1361 <mu_B_fct+0x231>
jmp    141a <mu_B_fct+0x2ea>
movl   $0x1,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1415 <mu_B_fct+0x2e5>
mov    -0x40(%rbp),%rax
mov    -0x28(%rbp),%ecx
imul   -0xc(%rbp),%ecx
add    -0x34(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x50(%rbp),%rax
mov    -0x10(%rbp),%ecx
imul   -0x28(%rbp),%ecx
mov    -0x70(%rbp),%rdx
movslq -0x28(%rbp),%rsi
add    (%rdx,%rsi,4),%ecx
add    -0x34(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    13c1 <mu_B_fct+0x291>
jmp    141a <mu_B_fct+0x2ea>
jmp    141f <mu_B_fct+0x2ef>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    133c <mu_B_fct+0x20c>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    152a <mu_B_fct+0x3fa>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x28(%rbp),%eax
jg     1517 <mu_B_fct+0x3e7>
mov    -0x2c(%rbp),%eax
imul   -0x10(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
mov    -0x2c(%rbp),%ecx
add    $0x1,%ecx
imul   -0x10(%rbp),%ecx
cmp    %ecx,%eax
jge    1504 <mu_B_fct+0x3d4>
mov    -0x50(%rbp),%rax
movslq -0x30(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x18(%rbp),%rax
mov    %rax,-0x90(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x28(%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
add    -0x30(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x58(%rbp),%rax
mov    %rax,-0x88(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x88(%rbp),%rax
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    145d <mu_B_fct+0x32d>
jmp    1509 <mu_B_fct+0x3d9>
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1447 <mu_B_fct+0x317>
jmp    151c <mu_B_fct+0x3ec>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1434 <mu_B_fct+0x304>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    15c3 <mu_B_fct+0x493>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
cmp    %ecx,%eax
jge    15b0 <mu_B_fct+0x480>
mov    -0x60(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x58(%rbp),%rax
mov    %rax,-0x98(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
imul   %ecx,%eax
mov    $0x2,%ecx
cltd
idiv   %ecx
mov    %eax,%ecx
mov    -0x98(%rbp),%rax
add    -0x2c(%rbp),%ecx
movslq %ecx,%rcx
addsd  (%rax,%rcx,8),%xmm0
mov    -0x60(%rbp),%rax
movslq -0x28(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    1544 <mu_B_fct+0x414>
jmp    15b5 <mu_B_fct+0x485>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1531 <mu_B_fct+0x401>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
cmp    -0x8(%rbp),%eax
jge    1607 <mu_B_fct+0x4d7>
mov    -0x60(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x30(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    15ca <mu_B_fct+0x49a>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    -0x10(%rbp),%ecx
imul   -0x8(%rbp),%ecx
cmp    %ecx,%eax
jge    1651 <mu_B_fct+0x521>
mov    -0x50(%rbp),%rax
movslq -0x2c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    0x28(%rbp),%rax
mov    -0x2c(%rbp),%ecx
imul   -0x4(%rbp),%ecx
add    -0x24(%rbp),%ecx
movslq %ecx,%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
jmp    160e <mu_B_fct+0x4de>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x58(%rbp),%rdi
call   1030 <free@plt>
mov    -0x60(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    116a <mu_B_fct+0x3a>
add    $0xb0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<mu_B_fct>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x1c8,%rsp
mov    %r9,0x180(%rsp)
mov    %r8,0xb0(%rsp)
mov    %edx,0x4(%rsp)
mov    %rsi,0x10(%rsp)
test   %edi,%edi
jle    1eca <mu_B_fct+0xd8a>
mov    %ecx,%r12d
mov    %ecx,%esi
mov    0x10(%rsp),%rdx
imul   %edx,%esi
lea    0x1(%rdx),%eax
imul   %edx,%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
movslq %ecx,%rax
mov    %rax,0x170(%rsp)
mov    0x4(%rsp),%r8d
mov    %r8d,%eax
imul   %edx,%eax
cltq
mov    %rax,0x168(%rsp)
movslq %edx,%rax
mov    %edi,%ebx
mov    %r8d,%edx
mov    %rax,0x160(%rsp)
mov    %eax,%edi
mov    %edx,%eax
and    $0xfffffffc,%eax
mov    %rax,0x1a0(%rsp)
add    $0xfffffffffffffffc,%rax
mov    %rax,0x198(%rsp)
mov    %rax,%rbp
shr    $0x2,%rbp
add    $0x1,%rbp
lea    -0x5(%rdx),%rax
mov    %rax,0x140(%rsp)
mov    %rax,%rcx
shr    $0x2,%rcx
add    $0x1,%rcx
mov    %edi,%eax
and    $0x3,%eax
mov    %rax,0xd0(%rsp)
mov    %edi,%eax
and    $0xfffffffc,%eax
mov    %rax,0xa0(%rsp)
mov    %rbp,%rax
mov    %rbp,0x190(%rsp)
and    $0xfffffffffffffffe,%rbp
mov    %rbp,0x148(%rsp)
mov    %rdx,%rax
neg    %rax
mov    %rax,0xe8(%rsp)
lea    -0x1(%rdx),%rax
mov    %rax,0x68(%rsp)
mov    %rax,%rbp
and    $0xfffffffffffffffc,%rbp
mov    %rcx,%rax
mov    %rcx,0x138(%rsp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,0x100(%rsp)
mov    %r12d,%eax
and    $0x3,%eax
mov    %eax,0x9c(%rsp)
mov    %esi,%eax
and    $0x3,%eax
mov    %rax,0x158(%rsp)
mov    %esi,%eax
and    $0xfffffffc,%eax
mov    %rax,0xf8(%rsp)
mov    %rbx,%rax
shl    $0x4,%rax
mov    %rax,0x48(%rsp)
mov    %rbx,%rax
shl    $0x5,%rax
mov    %rax,0x40(%rsp)
mov    0x220(%rsp),%r9
mov    0x218(%rsp),%r11
mov    0x210(%rsp),%r10
mov    0x208(%rsp),%rcx
movslq %esi,%rax
mov    %rax,0x150(%rsp)
mov    0xb0(%rsp),%rax
add    $0xffffffff,%eax
mov    %eax,0x94(%rsp)
lea    0x0(,%rdx,8),%rax
mov    %rax,0x120(%rsp)
movslq %r8d,%rax
mov    %rdx,0x28(%rsp)
lea    -0x2(%rdx),%rdx
mov    %rdx,0x188(%rsp)
lea    -0x1(%r12),%edx
mov    %rdx,0x88(%rsp)
mov    %rdi,0x78(%rsp)
lea    -0x1(%rdi),%rdx
mov    %rdx,0xa8(%rsp)
mov    %rsi,0x178(%rsp)
lea    -0x1(%rsi),%rdx
mov    %rdx,0x118(%rsp)
mov    %rbp,0x130(%rsp)
lea    0x1(%rbp),%rdx
mov    %rbx,%rbp
mov    %rdx,0x128(%rsp)
lea    0x0(,%rbx,8),%rdx
mov    %rdx,0x30(%rsp)
lea    (%rdx,%rdx,2),%rdx
mov    %rdx,0x38(%rsp)
lea    0x3(%r12),%edx
mov    %edx,0x90(%rsp)
lea    0x0(,%rax,8),%rdx
mov    %rdx,0x1b8(%rsp)
lea    0x30(,%rax,8),%rdx
mov    %rdx,0x110(%rsp)
mov    %rax,0xf0(%rsp)
lea    0x8(,%rax,8),%rax
mov    %rax,0x108(%rsp)
mov    %r12d,%r14d
lea    0x18(%rcx),%rax
mov    %rax,0x1c0(%rsp)
mov    %r11,0xc8(%rsp)
mov    %r9,0xb8(%rsp)
mov    %r10,0xc0(%rsp)
xor    %eax,%eax
mov    %rax,0x20(%rsp)
mov    %rbx,0x50(%rsp)
jmp    1474 <mu_B_fct+0x334>
nopl   0x0(%rax)
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r13,%rdi
call   1030 <free@plt>
mov    0xd8(%rsp),%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
mov    0x60(%rsp),%rdi
call   1030 <free@plt>
mov    0x1a8(%rsp),%rdi
call   1030 <free@plt>
mov    0x70(%rsp),%rdi
call   1030 <free@plt>
mov    0xe0(%rsp),%rdi
call   1030 <free@plt>
mov    0x58(%rsp),%rdi
call   1030 <free@plt>
mov    0x20(%rsp),%rcx
add    $0x1,%rcx
addq   $0x8,0xc0(%rsp)
addq   $0x8,0xb8(%rsp)
addq   $0x8,0xc8(%rsp)
mov    %rcx,%rax
mov    %rcx,0x20(%rsp)
cmp    %rbp,%rcx
je     1eca <mu_B_fct+0xd8a>
mov    $0x8,%esi
mov    0x150(%rsp),%rdi
call   1050 <calloc@plt>
mov    %rax,%r15
mov    $0x8,%esi
mov    0x170(%rsp),%rdi
call   1050 <calloc@plt>
mov    %rax,%r13
mov    $0x8,%esi
mov    0x168(%rsp),%rbx
mov    %rbx,%rdi
call   1050 <calloc@plt>
mov    %rax,0x8(%rsp)
mov    $0x8,%esi
mov    %rbx,%rdi
call   1050 <calloc@plt>
mov    %rax,0x60(%rsp)
mov    $0x8,%esi
mov    0x160(%rsp),%rbx
mov    %rbx,%rdi
call   1050 <calloc@plt>
mov    %rax,0xd8(%rsp)
mov    $0x8,%esi
mov    %rbx,%rdi
call   1050 <calloc@plt>
mov    %rax,%rbp
mov    $0x4,%esi
mov    %rbx,%rdi
call   1050 <calloc@plt>
mov    %rax,0x58(%rsp)
mov    $0x4,%esi
mov    %rbx,%rdi
call   1050 <calloc@plt>
mov    %rax,0x70(%rsp)
mov    $0x4,%esi
mov    %rbx,%rdi
call   1050 <calloc@plt>
mov    %rbp,%rcx
mov    %rax,%r11
test   %ebx,%ebx
mov    0x50(%rsp),%r10
mov    0xd0(%rsp),%r9
mov    0x30(%rsp),%r8
jle    1605 <mu_B_fct+0x4c5>
cmpq   $0x3,0xa8(%rsp)
jae    1560 <mu_B_fct+0x420>
xor    %eax,%eax
jmp    15c7 <mu_B_fct+0x487>
nopw   0x0(%rax,%rax,1)
mov    0xc0(%rsp),%rdx
xor    %eax,%eax
mov    0xa0(%rsp),%rdi
mov    0x48(%rsp),%rbp
mov    0x40(%rsp),%rbx
mov    0x38(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rdx),%xmm0
movsd  %xmm0,(%rcx,%rax,8)
movsd  (%rdx,%r10,8),%xmm0
movsd  %xmm0,0x8(%rcx,%rax,8)
movsd  (%rdx,%rbp,1),%xmm0
movsd  %xmm0,0x10(%rcx,%rax,8)
movsd  (%rdx,%rsi,1),%xmm0
movsd  %xmm0,0x18(%rcx,%rax,8)
add    $0x4,%rax
add    %rbx,%rdx
cmp    %rax,%rdi
jne    1590 <mu_B_fct+0x450>
test   %r9,%r9
je     1605 <mu_B_fct+0x4c5>
lea    (%rcx,%rax,8),%rsi
imul   %r10,%rax
add    0x20(%rsp),%rax
mov    0x210(%rsp),%rdx
lea    (%rdx,%rax,8),%rax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movsd  (%rax),%xmm0
movsd  %xmm0,(%rsi,%rdx,8)
add    $0x1,%rdx
add    %r8,%rax
cmp    %rdx,%r9
jne    15f0 <mu_B_fct+0x4b0>
sub    $0x8,%rsp
mov    0x208(%rsp),%rdi
mov    0x9c(%rsp),%esi
mov    0xc(%rsp),%edx
mov    0x18(%rsp),%rbp
mov    %ebp,%r8d
mov    0x60(%rsp),%r9
xor    %eax,%eax
push   0x68(%rsp)
push   %r11
push   %rbp
mov    %rcx,%rbx
mov    %r11,0x100(%rsp)
call   1040 <spline_basis@plt>
add    $0x18,%rsp
mov    0x188(%rsp),%rdi
mov    0xb8(%rsp),%rsi
mov    0xc(%rsp),%edx
mov    %rbx,0x1b0(%rsp)
mov    %rbx,%rcx
mov    0xe8(%rsp),%rbx
mov    %ebp,%r8d
mov    0x60(%rsp),%r9
xor    %eax,%eax
push   0x10(%rsp)
push   0x80(%rsp)
push   %rbp
call   1040 <spline_basis@plt>
add    $0x20,%rsp
cmpl   $0x0,0x4(%rsp)
mov    0x60(%rsp),%rsi
jle    16ac <mu_B_fct+0x56c>
movslq (%rbx),%rax
lea    (%r15,%rax,8),%rdi
mov    0x120(%rsp),%rdx
call   1060 <memcpy@plt>
cmpl   $0x2,0x10(%rsp)
mov    0x28(%rsp),%rsi
jl     1ae0 <mu_B_fct+0x9a0>
mov    0x110(%rsp),%rax
mov    0x8(%rsp),%rcx
add    %rcx,%rax
add    0x108(%rsp),%rcx
mov    $0x1,%edx
xor    %ebp,%ebp
mov    %r14,%r9
mov    0x88(%rsp),%r8
mov    0x90(%rsp),%edi
mov    %rdi,0x80(%rsp)
jmp    1740 <mu_B_fct+0x600>
nopw   0x0(%rax,%rax,1)
add    $0x1,%rdx
mov    0x98(%rsp),%ebp
add    $0x1,%ebp
mov    0x80(%rsp),%rdi
add    %r12d,%edi
mov    %rdi,0x80(%rsp)
mov    0x1b8(%rsp),%rdi
add    %rdi,%rax
add    %rdi,%rcx
add    %r14,%r8
add    %r14,%r9
cmp    0x78(%rsp),%rdx
je     1ae0 <mu_B_fct+0x9a0>
mov    %ebp,%ebx
imul   %r12d,%ebx
mov    0x70(%rsp),%rdi
mov    (%rdi,%rdx,4),%r10d
test   %r10d,%r10d
mov    %ebp,0x98(%rsp)
je     1840 <mu_B_fct+0x700>
cmpl   $0x0,0x4(%rsp)
jle    1700 <mu_B_fct+0x5c0>
mov    %rdx,%r11
imul   0xf0(%rsp),%r11
mov    %edx,%edi
imul   %r12d,%edi
add    %r10d,%edi
add    $0xffffffff,%edi
mov    %rdi,0x18(%rsp)
cmpl   $0x4,0x4(%rsp)
jb     18f0 <mu_B_fct+0x7b0>
add    0x88(%rsp),%ebx
add    %r10d,%ebx
mov    0x68(%rsp),%rbp
lea    (%rbx,%rbp,1),%edi
cmp    %ebx,%edi
jl     18f0 <mu_B_fct+0x7b0>
mov    %rbp,%rdi
shr    $0x20,%rdi
mov    $0x0,%ebp
jne    18f2 <mu_B_fct+0x7b2>
cmpq   $0x0,0x198(%rsp)
mov    %r11,0x1b0(%rsp)
je     19b3 <mu_B_fct+0x873>
mov    0x80(%rsp),%rdi
lea    (%r10,%rdi,1),%r11d
mov    0x148(%rsp),%rbp
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movups -0x30(%rax,%rbx,8),%xmm0
movups -0x20(%rax,%rbx,8),%xmm1
lea    -0x4(%r11),%edi
movslq %edi,%rdi
movups %xmm0,(%r15,%rdi,8)
movups %xmm1,0x10(%r15,%rdi,8)
movupd -0x10(%rax,%rbx,8),%xmm0
movupd (%rax,%rbx,8),%xmm1
movslq %r11d,%r11
movupd %xmm0,(%r15,%r11,8)
movupd %xmm1,0x10(%r15,%r11,8)
add    $0x8,%rbx
add    $0x8,%r11d
add    $0xfffffffffffffffe,%rbp
jne    17f0 <mu_B_fct+0x6b0>
jmp    19b5 <mu_B_fct+0x875>
nopw   0x0(%rax,%rax,1)
cmpl   $0x2,0x4(%rsp)
jl     1700 <mu_B_fct+0x5c0>
mov    %rdx,%rdi
imul   0xf0(%rsp),%rdi
mov    %edx,%r11d
imul   %r12d,%r11d
add    $0xffffffff,%r11d
mov    $0x1,%ebp
cmpq   $0x4,0x68(%rsp)
jae    1977 <mu_B_fct+0x837>
mov    %rbp,%rbx
test   $0x1,%sil
jne    189e <mu_B_fct+0x75e>
add    %rbp,%rdi
mov    0x8(%rsp),%rsi
movsd  (%rsi,%rdi,8),%xmm0
add    %ebp,%r11d
movslq %r11d,%rsi
movsd  %xmm0,(%r15,%rsi,8)
mov    0x28(%rsp),%rsi
lea    0x1(%rbp),%rbx
not    %rbp
cmp    0xe8(%rsp),%rbp
je     1700 <mu_B_fct+0x5c0>
nop
movsd  -0x8(%rcx,%rbx,8),%xmm0
lea    (%r8,%rbx,1),%esi
movslq %esi,%rsi
movsd  %xmm0,(%r15,%rsi,8)
movsd  (%rcx,%rbx,8),%xmm0
lea    (%r9,%rbx,1),%esi
movslq %esi,%rsi
movsd  %xmm0,(%r15,%rsi,8)
mov    0x28(%rsp),%rsi
add    $0x2,%rbx
cmp    %rbx,%rsi
jne    18b0 <mu_B_fct+0x770>
jmp    1700 <mu_B_fct+0x5c0>
nopl   0x0(%rax,%rax,1)
xor    %ebp,%ebp
mov    %rbp,%rbx
test   $0x1,%sil
je     1920 <mu_B_fct+0x7e0>
add    %rbp,%r11
mov    0x8(%rsp),%rdi
movsd  (%rdi,%r11,8),%xmm0
mov    0x18(%rsp),%rdi
add    %ebp,%edi
movslq %edi,%rdi
movsd  %xmm0,(%r15,%rdi,8)
mov    %rbp,%rbx
or     $0x1,%rbx
not    %rbp
cmp    0xe8(%rsp),%rbp
je     1700 <mu_B_fct+0x5c0>
lea    (%r10,%r8,1),%edi
lea    (%r9,%r10,1),%ebp
nopl   0x0(%rax)
movsd  -0x8(%rcx,%rbx,8),%xmm0
lea    (%rdi,%rbx,1),%esi
movslq %esi,%rsi
movsd  %xmm0,(%r15,%rsi,8)
movsd  (%rcx,%rbx,8),%xmm0
lea    0x0(%rbp,%rbx,1),%esi
movslq %esi,%rsi
movsd  %xmm0,(%r15,%rsi,8)
mov    0x28(%rsp),%rsi
add    $0x2,%rbx
cmp    %rbx,%rsi
jne    1940 <mu_B_fct+0x800>
jmp    1700 <mu_B_fct+0x5c0>
mov    %rdi,0x18(%rsp)
add    %r12d,%ebx
mov    0x188(%rsp),%r10
lea    (%rbx,%r10,1),%edi
cmp    %ebx,%edi
jl     1a0e <mu_B_fct+0x8ce>
mov    %r10,%rdi
shr    $0x20,%rdi
mov    0x18(%rsp),%rdi
jne    1873 <mu_B_fct+0x733>
cmpq   $0x4,0x140(%rsp)
jae    1a18 <mu_B_fct+0x8d8>
xor    %ebx,%ebx
jmp    1a74 <mu_B_fct+0x934>
xor    %ebx,%ebx
testb  $0x1,0x190(%rsp)
01
mov    0x1b0(%rsp),%r11
je     19f5 <mu_B_fct+0x8b5>
mov    %rbx,%rdi
add    %r11,%rdi
mov    0x8(%rsp),%rbp
movupd 0x0(%rbp,%rdi,8),%xmm0
movupd 0x10(%rbp,%rdi,8),%xmm1
mov    0x18(%rsp),%rdi
add    %ebx,%edi
movslq %edi,%rdi
movupd %xmm0,(%r15,%rdi,8)
movupd %xmm1,0x10(%r15,%rdi,8)
mov    0x1a0(%rsp),%rdi
mov    %rdi,%rbp
cmp    %rsi,%rdi
je     1700 <mu_B_fct+0x5c0>
jmp    18f2 <mu_B_fct+0x7b2>
mov    0x18(%rsp),%rdi
jmp    1873 <mu_B_fct+0x733>
mov    0x100(%rsp),%rbp
mov    %r9d,%edi
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nop
movups (%rcx,%rbx,8),%xmm0
movups 0x10(%rcx,%rbx,8),%xmm1
movslq %edi,%rdi
movups %xmm0,(%r15,%rdi,8)
movups %xmm1,0x10(%r15,%rdi,8)
movupd 0x20(%rcx,%rbx,8),%xmm0
movupd 0x30(%rcx,%rbx,8),%xmm1
lea    0x4(%rdi),%r10d
movslq %r10d,%rsi
movupd %xmm0,(%r15,%rsi,8)
movupd %xmm1,0x10(%r15,%rsi,8)
add    $0x8,%rbx
add    $0x8,%edi
add    $0xfffffffffffffffe,%rbp
jne    1a30 <mu_B_fct+0x8f0>
testb  $0x1,0x138(%rsp)
01
mov    0x18(%rsp),%rdi
je     1ab4 <mu_B_fct+0x974>
mov    %rbx,%rsi
or     $0x1,%rsi
or     $0x1,%ebx
add    %rdi,%rsi
mov    0x8(%rsp),%rbp
movupd 0x0(%rbp,%rsi,8),%xmm0
movupd 0x10(%rbp,%rsi,8),%xmm1
add    %r11d,%ebx
movslq %ebx,%rsi
movupd %xmm0,(%r15,%rsi,8)
movupd %xmm1,0x10(%r15,%rsi,8)
mov    0x128(%rsp),%rbp
mov    0x130(%rsp),%rsi
cmp    %rsi,0x68(%rsp)
mov    0x28(%rsp),%rsi
je     1700 <mu_B_fct+0x5c0>
jmp    1873 <mu_B_fct+0x733>
nopl   0x0(%rax)
cmpl   $0x0,0x10(%rsp)
mov    0x30(%rsp),%rbx
jle    1de0 <mu_B_fct+0xca0>
xor    %r8d,%r8d
mov    $0x1,%r10d
jmp    1b0f <mu_B_fct+0x9cf>
nopl   0x0(%rax,%rax,1)
add    $0x1,%r10
cmp    0x10(%rsp),%r8d
je     1c30 <mu_B_fct+0xaf0>
mov    %r8d,%r9d
lea    0x1(%r9),%r8d
imul   %r8d,%r9d
mov    %r9d,%eax
imul   %r12d,%eax
mov    %eax,%ecx
shr    $0x1f,%ecx
add    %eax,%ecx
sar    %ecx
shr    %r9d
movslq %ecx,%rax
mov    0x208(%rsp),%rcx
lea    (%rcx,%rax,8),%rsi
mov    0x1c0(%rsp),%rcx
lea    (%rcx,%rax,8),%rdi
mov    %r14,%rbp
xor    %r11d,%r11d
xor    %ecx,%ecx
jmp    1b72 <mu_B_fct+0xa32>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  %xmm0,0x0(%r13,%rbx,8)
add    %r12d,%ecx
add    %r14,%rbp
cmp    %r10,%r11
je     1b00 <mu_B_fct+0x9c0>
mov    %r11,%rbx
mov    %ebx,%eax
imul   %r12d,%eax
add    $0x1,%r11
mov    %r11d,%edx
imul   %r12d,%edx
cmp    %edx,%eax
jge    1b67 <mu_B_fct+0xa27>
add    %r9,%rbx
movslq %ecx,%rax
movsd  0x0(%r13,%rbx,8),%xmm0
mov    0x9c(%rsp),%edx
test   %edx,%edx
je     1bc8 <mu_B_fct+0xa88>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r15,%rax,8),%xmm1
mulsd  (%rsi,%rax,8),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rax
add    $0xffffffff,%edx
jne    1bb0 <mu_B_fct+0xa70>
cmpl   $0x3,0x88(%rsp)
03
jb     1b60 <mu_B_fct+0xa20>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movsd  (%r15,%rax,8),%xmm1
movsd  0x8(%r15,%rax,8),%xmm2
mulsd  -0x18(%rdi,%rax,8),%xmm1
mulsd  -0x10(%rdi,%rax,8),%xmm2
addsd  %xmm0,%xmm1
movsd  0x10(%r15,%rax,8),%xmm3
mulsd  -0x8(%rdi,%rax,8),%xmm3
addsd  %xmm1,%xmm2
movsd  0x18(%r15,%rax,8),%xmm0
mulsd  (%rdi,%rax,8),%xmm0
addsd  %xmm2,%xmm3
addsd  %xmm3,%xmm0
add    $0x4,%rax
cmp    %eax,%ebp
jne    1be0 <mu_B_fct+0xaa0>
jmp    1b60 <mu_B_fct+0xa20>
nop
cmpl   $0x0,0x10(%rsp)
mov    0xd0(%rsp),%r10
mov    0x30(%rsp),%rbx
mov    0xd8(%rsp),%r11
jle    1de0 <mu_B_fct+0xca0>
lea    0x18(%r13),%r8
mov    $0x1,%edx
xorpd  %xmm0,%xmm0
mov    $0x2,%r9d
xor    %ebp,%ebp
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
mov    %ebp,%esi
shr    %esi
cmp    $0x3,%rbx
jae    1c80 <mu_B_fct+0xb40>
xor    %eax,%eax
jmp    1cb0 <mu_B_fct+0xb70>
xchg   %ax,%ax
lea    (%r8,%rsi,8),%rdi
mov    %rdx,%rcx
and    $0xfffffffffffffffc,%rcx
xor    %eax,%eax
nopl   (%rax)
addsd  -0x18(%rdi,%rax,8),%xmm0
addsd  -0x10(%rdi,%rax,8),%xmm0
addsd  -0x8(%rdi,%rax,8),%xmm0
addsd  (%rdi,%rax,8),%xmm0
add    $0x4,%rax
cmp    %rax,%rcx
jne    1c90 <mu_B_fct+0xb50>
lea    0x1(%rbx),%rdi
test   $0x3,%dl
je     1cde <mu_B_fct+0xb9e>
mov    %edx,%ecx
and    $0x3,%ecx
add    %rsi,%rax
lea    0x0(,%rax,8),%rax
add    %r13,%rax
xor    %esi,%esi
xchg   %ax,%ax
addsd  (%rax,%rsi,8),%xmm0
add    $0x1,%rsi
cmp    %rsi,%rcx
jne    1cd0 <mu_B_fct+0xb90>
movsd  %xmm0,(%r11,%rbx,8)
cmp    0x78(%rsp),%rdi
je     1d10 <mu_B_fct+0xbd0>
add    $0x1,%rdx
movsd  (%r11,%rdi,8),%xmm0
add    %r9,%rbp
add    $0x2,%r9
mov    %rdi,%rbx
jmp    1c70 <mu_B_fct+0xb30>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
cmpl   $0x0,0x10(%rsp)
mov    0x30(%rsp),%rbx
jle    1de0 <mu_B_fct+0xca0>
cmpq   $0x3,0xa8(%rsp)
jae    1d2f <mu_B_fct+0xbef>
xor    %eax,%eax
jmp    1d8a <mu_B_fct+0xc4a>
mov    0xb8(%rsp),%rcx
xor    %eax,%eax
mov    0xa0(%rsp),%rdx
mov    0x48(%rsp),%rsi
mov    0x40(%rsp),%rdi
mov    0x38(%rsp),%rbp
movsd  (%r11,%rax,8),%xmm0
movsd  %xmm0,(%rcx)
movsd  0x8(%r11,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rbx,1)
movsd  0x10(%r11,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,1)
movsd  0x18(%r11,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rbp,1)
add    $0x4,%rax
add    %rdi,%rcx
cmp    %rax,%rdx
jne    1d50 <mu_B_fct+0xc10>
testb  $0x3,0x78(%rsp)
je     1de0 <mu_B_fct+0xca0>
mov    0x50(%rsp),%rcx
imul   %rax,%rcx
add    0x20(%rsp),%rcx
mov    0x220(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
lea    (%r11,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,(%rcx)
add    $0x1,%rdx
add    %rbx,%rcx
cmp    %rdx,%r10
jne    1dc0 <mu_B_fct+0xc80>
cs nopw 0x0(%rax,%rax,1)
nop
cmpl   $0x0,0x178(%rsp)
mov    0x50(%rsp),%rbp
mov    0x158(%rsp),%r8
jle    13e0 <mu_B_fct+0x2a0>
cmpq   $0x3,0x118(%rsp)
jae    1e10 <mu_B_fct+0xcd0>
mov    %rbp,%r9
xor    %eax,%eax
jmp    1e7a <mu_B_fct+0xd3a>
nopl   (%rax)
mov    %rbp,%r9
mov    0xc8(%rsp),%rcx
xor    %eax,%eax
mov    0xf8(%rsp),%rdx
mov    0x48(%rsp),%rdi
mov    0x40(%rsp),%rbp
mov    0x38(%rsp),%rsi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%r15,%rax,8),%xmm0
movsd  %xmm0,(%rcx)
movsd  0x8(%r15,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rbx,1)
movsd  0x10(%r15,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rdi,1)
movsd  0x18(%r15,%rax,8),%xmm0
movsd  %xmm0,(%rcx,%rsi,1)
add    $0x4,%rax
add    %rbp,%rcx
cmp    %rax,%rdx
jne    1e40 <mu_B_fct+0xd00>
test   %r8,%r8
mov    %r9,%rbp
je     13e0 <mu_B_fct+0x2a0>
mov    %rbp,%rcx
imul   %rax,%rcx
add    0x20(%rsp),%rcx
mov    0x218(%rsp),%rdx
lea    (%rdx,%rcx,8),%rcx
lea    (%r15,%rax,8),%rax
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movsd  (%rax,%rdx,8),%xmm0
movsd  %xmm0,(%rcx)
add    $0x1,%rdx
add    %rbx,%rcx
cmp    %rdx,%r8
jne    1eb0 <mu_B_fct+0xd70>
jmp    13e0 <mu_B_fct+0x2a0>
add    $0x1c8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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