void rmatmult_3_at(void **rmatmult3_args, double *x, double *b) {
  int i, ii, jj, kk;
  int imin = *((int *)(rmatmult3_args[0]));
  int imax = *((int *)(rmatmult3_args[1]));
  int jmin = *((int *)(rmatmult3_args[2]));
  int jmax = *((int *)(rmatmult3_args[3]));
  int kmin = *((int *)(rmatmult3_args[4]));
  int kmax = *((int *)(rmatmult3_args[5]));
  int jp = *((int *)(rmatmult3_args[6]));
  int kp = *((int *)(rmatmult3_args[7]));
  const double *dbl = *((const double **)(rmatmult3_args[8]));
  const double *dbc = *((const double **)(rmatmult3_args[9]));
  const double *dbr = *((const double **)(rmatmult3_args[10]));
  const double *dcl = *((const double **)(rmatmult3_args[11]));
  const double *dcc = *((const double **)(rmatmult3_args[12]));
  const double *dcr = *((const double **)(rmatmult3_args[13]));
  const double *dfl = *((const double **)(rmatmult3_args[14]));
  const double *dfc = *((const double **)(rmatmult3_args[15]));
  const double *dfr = *((const double **)(rmatmult3_args[16]));
  const double *cbl = *((const double **)(rmatmult3_args[17]));
  const double *cbc = *((const double **)(rmatmult3_args[18]));
  const double *cbr = *((const double **)(rmatmult3_args[19]));
  const double *ccl = *((const double **)(rmatmult3_args[20]));
  const double *ccc = *((const double **)(rmatmult3_args[21]));
  const double *ccr = *((const double **)(rmatmult3_args[22]));
  const double *cfl = *((const double **)(rmatmult3_args[23]));
  const double *cfc = *((const double **)(rmatmult3_args[24]));
  const double *cfr = *((const double **)(rmatmult3_args[25]));
  const double *ubl = *((const double **)(rmatmult3_args[26]));
  const double *ubc = *((const double **)(rmatmult3_args[27]));
  const double *ubr = *((const double **)(rmatmult3_args[28]));
  const double *ucl = *((const double **)(rmatmult3_args[29]));
  const double *ucc = *((const double **)(rmatmult3_args[30]));
  const double *ucr = *((const double **)(rmatmult3_args[31]));
  const double *ufl = *((const double **)(rmatmult3_args[32]));
  const double *ufc = *((const double **)(rmatmult3_args[33]));
  const double *ufr = *((const double **)(rmatmult3_args[34]));
  double *xdbl = x - kp - jp - 1;
  double *xdbc = x - kp - jp;
  double *xdbr = x - kp - jp + 1;
  double *xdcl = x - kp - 1;
  double *xdcc = x - kp;
  double *xdcr = x - kp + 1;
  double *xdfl = x - kp + jp - 1;
  double *xdfc = x - kp + jp;
  double *xdfr = x - kp + jp + 1;
  double *xcbl = x - jp - 1;
  double *xcbc = x - jp;
  double *xcbr = x - jp + 1;
  double *xccl = x - 1;
  double *xccc = x;
  double *xccr = x + 1;
  double *xcfl = x + jp - 1;
  double *xcfc = x + jp;
  double *xcfr = x + jp + 1;
  double *xubl = x + kp - jp - 1;
  double *xubc = x + kp - jp;
  double *xubr = x + kp - jp + 1;
  double *xucl = x + kp - 1;
  double *xucc = x + kp;
  double *xucr = x + kp + 1;
  double *xufl = x + kp + jp - 1;
  double *xufc = x + kp + jp;
  double *xufr = x + kp + jp + 1;
  for (kk = 2; kk < kmax; kk++) {
    for (jj = 2; jj < jmax; jj++) {
      for (ii = 2; ii < imax; ii++) {
        i = ii + jj * jp + kk * kp;
        b[i] = dbl[i] * xdbl[i] + dbc[i] * xdbc[i] + dbr[i] * xdbr[i] +
               dcl[i] * xdcl[i] + dcc[i] * xdcc[i] + dcr[i] * xdcr[i] +
               dfl[i] * xdfl[i] + dfc[i] * xdfc[i] + dfr[i] * xdfr[i] +
               cbl[i] * xcbl[i] + cbc[i] * xcbc[i] + cbr[i] * xcbr[i] +
               ccl[i] * xccl[i] + ccc[i] * xccc[i] + ccr[i] * xccr[i] +
               cfl[i] * xcfl[i] + cfc[i] * xcfc[i] + cfr[i] * xcfr[i] +
               ubl[i] * xubl[i] + ubc[i] * xubc[i] + ubr[i] * xubr[i] +
               ucl[i] * xucl[i] + ucc[i] * xucc[i] + ucr[i] * xucr[i] +
               ufl[i] * xufl[i] + ufc[i] * xufc[i] + ufr[i] * xufr[i];
      }
    }
  }
}


x86 assembly (clang, -O0):
<rmatmult_3_at>:
push   %rbp
mov    %rsp,%rbp
sub    $0x178,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
mov    (%rax),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
mov    (%rax),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rax
mov    (%rax),%eax
mov    %eax,-0x38(%rbp)
mov    -0x8(%rbp),%rax
mov    0x20(%rax),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
mov    0x28(%rax),%rax
mov    (%rax),%eax
mov    %eax,-0x40(%rbp)
mov    -0x8(%rbp),%rax
mov    0x30(%rax),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
mov    -0x8(%rbp),%rax
mov    0x38(%rax),%rax
mov    (%rax),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    0x40(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
mov    0x48(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    0x50(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0x60(%rbp)
mov    -0x8(%rbp),%rax
mov    0x58(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0x68(%rbp)
mov    -0x8(%rbp),%rax
mov    0x60(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0x70(%rbp)
mov    -0x8(%rbp),%rax
mov    0x68(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0x78(%rbp)
mov    -0x8(%rbp),%rax
mov    0x70(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0x80(%rbp)
mov    -0x8(%rbp),%rax
mov    0x78(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0x88(%rbp)
mov    -0x8(%rbp),%rax
mov    0x80(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0x90(%rbp)
mov    -0x8(%rbp),%rax
mov    0x88(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0x98(%rbp)
mov    -0x8(%rbp),%rax
mov    0x90(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x8(%rbp),%rax
mov    0x98(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0xa8(%rbp)
mov    -0x8(%rbp),%rax
mov    0xa0(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0xb0(%rbp)
mov    -0x8(%rbp),%rax
mov    0xa8(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0xb8(%rbp)
mov    -0x8(%rbp),%rax
mov    0xb0(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0xc0(%rbp)
mov    -0x8(%rbp),%rax
mov    0xb8(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0xc8(%rbp)
mov    -0x8(%rbp),%rax
mov    0xc0(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0xd0(%rbp)
mov    -0x8(%rbp),%rax
mov    0xc8(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0xd8(%rbp)
mov    -0x8(%rbp),%rax
mov    0xd0(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0xe0(%rbp)
mov    -0x8(%rbp),%rax
mov    0xd8(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0xe8(%rbp)
mov    -0x8(%rbp),%rax
mov    0xe0(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0xf0(%rbp)
mov    -0x8(%rbp),%rax
mov    0xe8(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0xf8(%rbp)
mov    -0x8(%rbp),%rax
mov    0xf0(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0x100(%rbp)
mov    -0x8(%rbp),%rax
mov    0xf8(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0x108(%rbp)
mov    -0x8(%rbp),%rax
mov    0x100(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0x110(%rbp)
mov    -0x8(%rbp),%rax
mov    0x108(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0x118(%rbp)
mov    -0x8(%rbp),%rax
mov    0x110(%rax),%rax
mov    (%rax),%rax
mov    %rax,-0x120(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x128(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x130(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0x8,%rax
mov    %rax,-0x138(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x140(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x148(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0x8,%rax
mov    %rax,-0x150(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x158(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x160(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0x8,%rax
mov    %rax,-0x168(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x170(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x178(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0x8,%rax
mov    %rax,-0x180(%rbp)
mov    -0x10(%rbp),%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x188(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x190(%rbp)
mov    -0x10(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x198(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x1a0(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x1a8(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x44(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0x8,%rax
mov    %rax,-0x1b0(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x1c0(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0x8,%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x1d8(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0x8,%rax
mov    %rax,-0x1e0(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x1e8(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x1f0(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x48(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x44(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
add    $0x8,%rax
mov    %rax,-0x1f8(%rbp)
movl   $0x2,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x40(%rbp),%eax
jge    1b8c <rmatmult_3_at+0xa8c>
movl   $0x2,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x38(%rbp),%eax
jge    1b79 <rmatmult_3_at+0xa79>
movl   $0x2,-0x20(%rbp)
mov    -0x20(%rbp),%eax
cmp    -0x30(%rbp),%eax
jge    1b66 <rmatmult_3_at+0xa66>
mov    -0x20(%rbp),%eax
mov    -0x24(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    %ecx,%eax
mov    -0x28(%rbp),%ecx
imul   -0x48(%rbp),%ecx
add    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x50(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x128(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mov    -0x58(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x130(%rbp),%rax
movslq -0x1c(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x60(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x138(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x68(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x140(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x70(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x148(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x78(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x150(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x80(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x158(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x88(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x160(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x90(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x168(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x98(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x170(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xa0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x178(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xa8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x180(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xb0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x188(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xb8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x190(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xc0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x198(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xc8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x1a0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xd0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x1a8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xd8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x1b0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xe0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x1b8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xe8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x1c0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0xf0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x1c8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0xf8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x1d0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x100(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x1d8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x108(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x1e0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x110(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x1e8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x118(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x1f0(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm1
addsd  %xmm0,%xmm1
mov    -0x120(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x1f8(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm2
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
mov    -0x18(%rbp),%rax
movslq -0x1c(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x20(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20(%rbp)
jmp    170c <rmatmult_3_at+0x60c>
jmp    1b6b <rmatmult_3_at+0xa6b>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    16f9 <rmatmult_3_at+0x5f9>
jmp    1b7e <rmatmult_3_at+0xa7e>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    16e6 <rmatmult_3_at+0x5e6>
add    $0x178,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rmatmult_3_at>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x98,%rsp
mov    %rdx,0x90(%rsp)
mov    0x28(%rdi),%rax
mov    (%rax),%eax
mov    %eax,-0x74(%rsp)
cmp    $0x3,%eax
jl     1626 <rmatmult_3_at+0x526>
mov    %rsi,%r11
mov    %rdi,%rsi
mov    0x8(%rdi),%rax
mov    0x18(%rdi),%rcx
mov    (%rax),%r9d
mov    (%rcx),%eax
mov    %eax,-0x78(%rsp)
mov    0x30(%rdi),%rax
movslq (%rax),%rbp
mov    0x38(%rdi),%rax
movslq (%rax),%rdi
mov    0x40(%rsi),%rax
mov    (%rax),%rax
mov    %rax,0x88(%rsp)
mov    0x48(%rsi),%rax
mov    (%rax),%rax
mov    %rax,-0x48(%rsp)
mov    0x50(%rsi),%rax
mov    (%rax),%rax
mov    %rax,-0x50(%rsp)
mov    0x58(%rsi),%rax
mov    (%rax),%rax
mov    %rax,-0x58(%rsp)
lea    0x0(,%rdi,8),%rax
mov    %r11,%r15
sub    %rax,%r15
lea    0x0(,%rbp,8),%rdx
mov    %r15,%r14
sub    %rdx,%r14
mov    %r11,%rax
sub    %rdx,%rax
lea    (%r11,%rdi,8),%r10
mov    %r10,%r8
sub    %rdx,%r8
mov    0x60(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,0x80(%rsp)
mov    0x68(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,0x78(%rsp)
mov    0x70(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,0x70(%rsp)
mov    0x78(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,0x68(%rsp)
mov    0x80(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,0x60(%rsp)
mov    0x88(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,0x58(%rsp)
mov    0x90(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,0x50(%rsp)
mov    0x98(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,0x48(%rsp)
mov    0xa0(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,0x40(%rsp)
mov    0xa8(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,0x38(%rsp)
mov    0xb0(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,0x30(%rsp)
mov    0xb8(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,0x28(%rsp)
mov    0xc0(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,0x20(%rsp)
mov    0xc8(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,0x18(%rsp)
mov    0xd0(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,0x10(%rsp)
mov    0xd8(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,0x8(%rsp)
mov    0xe0(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,(%rsp)
mov    0xe8(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,-0x8(%rsp)
mov    0xf0(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,-0x10(%rsp)
mov    0xf8(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,-0x18(%rsp)
mov    0x100(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,-0x20(%rsp)
mov    0x108(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,-0x28(%rsp)
mov    0x110(%rsi),%rdx
mov    (%rdx),%rdx
mov    %rdx,-0x30(%rsp)
lea    0x0(%rbp,%rbp,1),%edx
mov    %rdi,-0x68(%rsp)
lea    0x2(%rdx,%rdi,2),%edx
mov    %edx,-0x80(%rsp)
lea    (%r15,%rbp,8),%rdx
lea    (%r11,%rbp,8),%r12
mov    %rbp,-0x40(%rsp)
lea    (%r10,%rbp,8),%r13
mov    %r9,-0x38(%rsp)
lea    -0x2(%r9),%rdi
mov    %rdi,-0x60(%rsp)
mov    $0x2,%ebp
mov    -0x48(%rsp),%rbx
mov    -0x50(%rsp),%rsi
mov    -0x58(%rsp),%rcx
jmp    136d <rmatmult_3_at+0x26d>
cs nopw 0x0(%rax,%rax,1)
nop
mov    -0x70(%rsp),%ebp
add    $0x1,%ebp
mov    -0x80(%rsp),%edi
add    -0x68(%rsp),%edi
mov    %edi,-0x80(%rsp)
cmp    -0x74(%rsp),%ebp
je     1626 <rmatmult_3_at+0x526>
mov    %ebp,-0x70(%rsp)
cmpl   $0x3,-0x78(%rsp)
jl     1350 <rmatmult_3_at+0x250>
mov    $0x2,%edi
mov    -0x80(%rsp),%ebp
mov    %ebp,-0x7c(%rsp)
jmp    13a9 <rmatmult_3_at+0x2a9>
nopw   0x0(%rax,%rax,1)
mov    -0x6c(%rsp),%edi
add    $0x1,%edi
mov    -0x7c(%rsp),%ebp
add    -0x40(%rsp),%ebp
mov    %ebp,-0x7c(%rsp)
cmp    -0x78(%rsp),%edi
je     1350 <rmatmult_3_at+0x250>
mov    %edi,-0x6c(%rsp)
cmpl   $0x3,-0x38(%rsp)
jl     1390 <rmatmult_3_at+0x290>
mov    -0x60(%rsp),%rbp
mov    -0x7c(%rsp),%edi
mov    %edi,%r9d
movslq %r9d,%r9
mov    %r11,%rdi
mov    0x88(%rsp),%r11
movsd  (%r11,%r9,8),%xmm0
mov    %rdi,%r11
movsd  (%rbx,%r9,8),%xmm1
mulsd  (%r14,%r9,8),%xmm1
mulsd  -0x8(%r14,%r9,8),%xmm0
addsd  %xmm1,%xmm0
movsd  (%rsi,%r9,8),%xmm1
mulsd  0x8(%r14,%r9,8),%xmm1
addsd  %xmm0,%xmm1
movsd  (%rcx,%r9,8),%xmm0
mulsd  -0x8(%r15,%r9,8),%xmm0
addsd  %xmm1,%xmm0
mov    0x80(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm1
mulsd  (%r15,%r9,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x78(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm0
mulsd  0x8(%r15,%r9,8),%xmm0
addsd  %xmm1,%xmm0
mov    0x70(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm1
mulsd  -0x8(%rdx,%r9,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x68(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm0
mulsd  (%rdx,%r9,8),%xmm0
addsd  %xmm1,%xmm0
mov    0x60(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm1
mulsd  0x8(%rdx,%r9,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x58(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm0
mulsd  -0x8(%rax,%r9,8),%xmm0
addsd  %xmm1,%xmm0
mov    0x50(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm1
mulsd  (%rax,%r9,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x48(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm0
mulsd  0x8(%rax,%r9,8),%xmm0
addsd  %xmm1,%xmm0
mov    0x40(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm1
mulsd  -0x8(%r11,%r9,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x38(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm0
mulsd  (%r11,%r9,8),%xmm0
addsd  %xmm1,%xmm0
mov    0x30(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm1
mulsd  0x8(%r11,%r9,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x28(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm0
mulsd  -0x8(%r12,%r9,8),%xmm0
addsd  %xmm1,%xmm0
mov    0x20(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm1
mulsd  (%r12,%r9,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x18(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm0
mulsd  0x8(%r12,%r9,8),%xmm0
addsd  %xmm1,%xmm0
mov    0x10(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm1
mulsd  -0x8(%r8,%r9,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x8(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm0
mulsd  (%r8,%r9,8),%xmm0
addsd  %xmm1,%xmm0
mov    (%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm1
mulsd  0x8(%r8,%r9,8),%xmm1
addsd  %xmm0,%xmm1
mov    -0x8(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm0
mulsd  -0x8(%r10,%r9,8),%xmm0
addsd  %xmm1,%xmm0
mov    -0x10(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm1
mulsd  (%r10,%r9,8),%xmm1
addsd  %xmm0,%xmm1
mov    -0x18(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm0
mulsd  0x8(%r10,%r9,8),%xmm0
addsd  %xmm1,%xmm0
mov    -0x20(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm1
mulsd  -0x8(%r13,%r9,8),%xmm1
addsd  %xmm0,%xmm1
mov    -0x28(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm0
mulsd  0x0(%r13,%r9,8),%xmm0
addsd  %xmm1,%xmm0
mov    -0x30(%rsp),%rdi
movsd  (%rdi,%r9,8),%xmm1
mulsd  0x8(%r13,%r9,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x90(%rsp),%rdi
movsd  %xmm1,(%rdi,%r9,8)
add    $0x1,%r9d
add    $0xffffffffffffffff,%rbp
jne    13c0 <rmatmult_3_at+0x2c0>
jmp    1390 <rmatmult_3_at+0x290>
add    $0x98,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @rmatmult_3_at(i8** %0, double* %1, double* %2) {
%4 = alloca i8**
%5 = alloca double*
%6 = alloca double*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca double*
%20 = alloca double*
%21 = alloca double*
%22 = alloca double*
%23 = alloca double*
%24 = alloca double*
%25 = alloca double*
%26 = alloca double*
%27 = alloca double*
%28 = alloca double*
%29 = alloca double*
%30 = alloca double*
%31 = alloca double*
%32 = alloca double*
%33 = alloca double*
%34 = alloca double*
%35 = alloca double*
%36 = alloca double*
%37 = alloca double*
%38 = alloca double*
%39 = alloca double*
%40 = alloca double*
%41 = alloca double*
%42 = alloca double*
%43 = alloca double*
%44 = alloca double*
%45 = alloca double*
%46 = alloca double*
%47 = alloca double*
%48 = alloca double*
%49 = alloca double*
%50 = alloca double*
%51 = alloca double*
%52 = alloca double*
%53 = alloca double*
%54 = alloca double*
%55 = alloca double*
%56 = alloca double*
%57 = alloca double*
%58 = alloca double*
%59 = alloca double*
%60 = alloca double*
%61 = alloca double*
%62 = alloca double*
%63 = alloca double*
%64 = alloca double*
%65 = alloca double*
%66 = alloca double*
%67 = alloca double*
%68 = alloca double*
%69 = alloca double*
%70 = alloca double*
%71 = alloca double*
%72 = alloca double*
store i8** %0, i8*** %4
store double* %1, double** %5
store double* %2, double** %6
%73 = load i8**, i8*** %4
%74 = getelementptr inbounds i8*, i8** %73, i64 0
%75 = load i8*, i8** %74
%76 = bitcast i8* %75 to i32*
%77 = load i32, i32* %76
store i32 %77, i32* %11
%78 = load i8**, i8*** %4
%79 = getelementptr inbounds i8*, i8** %78, i64 1
%80 = load i8*, i8** %79
%81 = bitcast i8* %80 to i32*
%82 = load i32, i32* %81
store i32 %82, i32* %12
%83 = load i8**, i8*** %4
%84 = getelementptr inbounds i8*, i8** %83, i64 2
%85 = load i8*, i8** %84
%86 = bitcast i8* %85 to i32*
%87 = load i32, i32* %86
store i32 %87, i32* %13
%88 = load i8**, i8*** %4
%89 = getelementptr inbounds i8*, i8** %88, i64 3
%90 = load i8*, i8** %89
%91 = bitcast i8* %90 to i32*
%92 = load i32, i32* %91
store i32 %92, i32* %14
%93 = load i8**, i8*** %4
%94 = getelementptr inbounds i8*, i8** %93, i64 4
%95 = load i8*, i8** %94
%96 = bitcast i8* %95 to i32*
%97 = load i32, i32* %96
store i32 %97, i32* %15
%98 = load i8**, i8*** %4
%99 = getelementptr inbounds i8*, i8** %98, i64 5
%100 = load i8*, i8** %99
%101 = bitcast i8* %100 to i32*
%102 = load i32, i32* %101
store i32 %102, i32* %16
%103 = load i8**, i8*** %4
%104 = getelementptr inbounds i8*, i8** %103, i64 6
%105 = load i8*, i8** %104
%106 = bitcast i8* %105 to i32*
%107 = load i32, i32* %106
store i32 %107, i32* %17
%108 = load i8**, i8*** %4
%109 = getelementptr inbounds i8*, i8** %108, i64 7
%110 = load i8*, i8** %109
%111 = bitcast i8* %110 to i32*
%112 = load i32, i32* %111
store i32 %112, i32* %18
%113 = load i8**, i8*** %4
%114 = getelementptr inbounds i8*, i8** %113, i64 8
%115 = load i8*, i8** %114
%116 = bitcast i8* %115 to double**
%117 = load double*, double** %116
store double* %117, double** %19
%118 = load i8**, i8*** %4
%119 = getelementptr inbounds i8*, i8** %118, i64 9
%120 = load i8*, i8** %119
%121 = bitcast i8* %120 to double**
%122 = load double*, double** %121
store double* %122, double** %20
%123 = load i8**, i8*** %4
%124 = getelementptr inbounds i8*, i8** %123, i64 10
%125 = load i8*, i8** %124
%126 = bitcast i8* %125 to double**
%127 = load double*, double** %126
store double* %127, double** %21
%128 = load i8**, i8*** %4
%129 = getelementptr inbounds i8*, i8** %128, i64 11
%130 = load i8*, i8** %129
%131 = bitcast i8* %130 to double**
%132 = load double*, double** %131
store double* %132, double** %22
%133 = load i8**, i8*** %4
%134 = getelementptr inbounds i8*, i8** %133, i64 12
%135 = load i8*, i8** %134
%136 = bitcast i8* %135 to double**
%137 = load double*, double** %136
store double* %137, double** %23
%138 = load i8**, i8*** %4
%139 = getelementptr inbounds i8*, i8** %138, i64 13
%140 = load i8*, i8** %139
%141 = bitcast i8* %140 to double**
%142 = load double*, double** %141
store double* %142, double** %24
%143 = load i8**, i8*** %4
%144 = getelementptr inbounds i8*, i8** %143, i64 14
%145 = load i8*, i8** %144
%146 = bitcast i8* %145 to double**
%147 = load double*, double** %146
store double* %147, double** %25
%148 = load i8**, i8*** %4
%149 = getelementptr inbounds i8*, i8** %148, i64 15
%150 = load i8*, i8** %149
%151 = bitcast i8* %150 to double**
%152 = load double*, double** %151
store double* %152, double** %26
%153 = load i8**, i8*** %4
%154 = getelementptr inbounds i8*, i8** %153, i64 16
%155 = load i8*, i8** %154
%156 = bitcast i8* %155 to double**
%157 = load double*, double** %156
store double* %157, double** %27
%158 = load i8**, i8*** %4
%159 = getelementptr inbounds i8*, i8** %158, i64 17
%160 = load i8*, i8** %159
%161 = bitcast i8* %160 to double**
%162 = load double*, double** %161
store double* %162, double** %28
%163 = load i8**, i8*** %4
%164 = getelementptr inbounds i8*, i8** %163, i64 18
%165 = load i8*, i8** %164
%166 = bitcast i8* %165 to double**
%167 = load double*, double** %166
store double* %167, double** %29
%168 = load i8**, i8*** %4
%169 = getelementptr inbounds i8*, i8** %168, i64 19
%170 = load i8*, i8** %169
%171 = bitcast i8* %170 to double**
%172 = load double*, double** %171
store double* %172, double** %30
%173 = load i8**, i8*** %4
%174 = getelementptr inbounds i8*, i8** %173, i64 20
%175 = load i8*, i8** %174
%176 = bitcast i8* %175 to double**
%177 = load double*, double** %176
store double* %177, double** %31
%178 = load i8**, i8*** %4
%179 = getelementptr inbounds i8*, i8** %178, i64 21
%180 = load i8*, i8** %179
%181 = bitcast i8* %180 to double**
%182 = load double*, double** %181
store double* %182, double** %32
%183 = load i8**, i8*** %4
%184 = getelementptr inbounds i8*, i8** %183, i64 22
%185 = load i8*, i8** %184
%186 = bitcast i8* %185 to double**
%187 = load double*, double** %186
store double* %187, double** %33
%188 = load i8**, i8*** %4
%189 = getelementptr inbounds i8*, i8** %188, i64 23
%190 = load i8*, i8** %189
%191 = bitcast i8* %190 to double**
%192 = load double*, double** %191
store double* %192, double** %34
%193 = load i8**, i8*** %4
%194 = getelementptr inbounds i8*, i8** %193, i64 24
%195 = load i8*, i8** %194
%196 = bitcast i8* %195 to double**
%197 = load double*, double** %196
store double* %197, double** %35
%198 = load i8**, i8*** %4
%199 = getelementptr inbounds i8*, i8** %198, i64 25
%200 = load i8*, i8** %199
%201 = bitcast i8* %200 to double**
%202 = load double*, double** %201
store double* %202, double** %36
%203 = load i8**, i8*** %4
%204 = getelementptr inbounds i8*, i8** %203, i64 26
%205 = load i8*, i8** %204
%206 = bitcast i8* %205 to double**
%207 = load double*, double** %206
store double* %207, double** %37
%208 = load i8**, i8*** %4
%209 = getelementptr inbounds i8*, i8** %208, i64 27
%210 = load i8*, i8** %209
%211 = bitcast i8* %210 to double**
%212 = load double*, double** %211
store double* %212, double** %38
%213 = load i8**, i8*** %4
%214 = getelementptr inbounds i8*, i8** %213, i64 28
%215 = load i8*, i8** %214
%216 = bitcast i8* %215 to double**
%217 = load double*, double** %216
store double* %217, double** %39
%218 = load i8**, i8*** %4
%219 = getelementptr inbounds i8*, i8** %218, i64 29
%220 = load i8*, i8** %219
%221 = bitcast i8* %220 to double**
%222 = load double*, double** %221
store double* %222, double** %40
%223 = load i8**, i8*** %4
%224 = getelementptr inbounds i8*, i8** %223, i64 30
%225 = load i8*, i8** %224
%226 = bitcast i8* %225 to double**
%227 = load double*, double** %226
store double* %227, double** %41
%228 = load i8**, i8*** %4
%229 = getelementptr inbounds i8*, i8** %228, i64 31
%230 = load i8*, i8** %229
%231 = bitcast i8* %230 to double**
%232 = load double*, double** %231
store double* %232, double** %42
%233 = load i8**, i8*** %4
%234 = getelementptr inbounds i8*, i8** %233, i64 32
%235 = load i8*, i8** %234
%236 = bitcast i8* %235 to double**
%237 = load double*, double** %236
store double* %237, double** %43
%238 = load i8**, i8*** %4
%239 = getelementptr inbounds i8*, i8** %238, i64 33
%240 = load i8*, i8** %239
%241 = bitcast i8* %240 to double**
%242 = load double*, double** %241
store double* %242, double** %44
%243 = load i8**, i8*** %4
%244 = getelementptr inbounds i8*, i8** %243, i64 34
%245 = load i8*, i8** %244
%246 = bitcast i8* %245 to double**
%247 = load double*, double** %246
store double* %247, double** %45
%248 = load double*, double** %5
%249 = load i32, i32* %18
%250 = sext i32 %249 to i64
%251 = sub i64 0, %250
%252 = getelementptr inbounds double, double* %248, i64 %251
%253 = load i32, i32* %17
%254 = sext i32 %253 to i64
%255 = sub i64 0, %254
%256 = getelementptr inbounds double, double* %252, i64 %255
%257 = getelementptr inbounds double, double* %256, i64 -1
store double* %257, double** %46
%258 = load double*, double** %5
%259 = load i32, i32* %18
%260 = sext i32 %259 to i64
%261 = sub i64 0, %260
%262 = getelementptr inbounds double, double* %258, i64 %261
%263 = load i32, i32* %17
%264 = sext i32 %263 to i64
%265 = sub i64 0, %264
%266 = getelementptr inbounds double, double* %262, i64 %265
store double* %266, double** %47
%267 = load double*, double** %5
%268 = load i32, i32* %18
%269 = sext i32 %268 to i64
%270 = sub i64 0, %269
%271 = getelementptr inbounds double, double* %267, i64 %270
%272 = load i32, i32* %17
%273 = sext i32 %272 to i64
%274 = sub i64 0, %273
%275 = getelementptr inbounds double, double* %271, i64 %274
%276 = getelementptr inbounds double, double* %275, i64 1
store double* %276, double** %48
%277 = load double*, double** %5
%278 = load i32, i32* %18
%279 = sext i32 %278 to i64
%280 = sub i64 0, %279
%281 = getelementptr inbounds double, double* %277, i64 %280
%282 = getelementptr inbounds double, double* %281, i64 -1
store double* %282, double** %49
%283 = load double*, double** %5
%284 = load i32, i32* %18
%285 = sext i32 %284 to i64
%286 = sub i64 0, %285
%287 = getelementptr inbounds double, double* %283, i64 %286
store double* %287, double** %50
%288 = load double*, double** %5
%289 = load i32, i32* %18
%290 = sext i32 %289 to i64
%291 = sub i64 0, %290
%292 = getelementptr inbounds double, double* %288, i64 %291
%293 = getelementptr inbounds double, double* %292, i64 1
store double* %293, double** %51
%294 = load double*, double** %5
%295 = load i32, i32* %18
%296 = sext i32 %295 to i64
%297 = sub i64 0, %296
%298 = getelementptr inbounds double, double* %294, i64 %297
%299 = load i32, i32* %17
%300 = sext i32 %299 to i64
%301 = getelementptr inbounds double, double* %298, i64 %300
%302 = getelementptr inbounds double, double* %301, i64 -1
store double* %302, double** %52
%303 = load double*, double** %5
%304 = load i32, i32* %18
%305 = sext i32 %304 to i64
%306 = sub i64 0, %305
%307 = getelementptr inbounds double, double* %303, i64 %306
%308 = load i32, i32* %17
%309 = sext i32 %308 to i64
%310 = getelementptr inbounds double, double* %307, i64 %309
store double* %310, double** %53
%311 = load double*, double** %5
%312 = load i32, i32* %18
%313 = sext i32 %312 to i64
%314 = sub i64 0, %313
%315 = getelementptr inbounds double, double* %311, i64 %314
%316 = load i32, i32* %17
%317 = sext i32 %316 to i64
%318 = getelementptr inbounds double, double* %315, i64 %317
%319 = getelementptr inbounds double, double* %318, i64 1
store double* %319, double** %54
%320 = load double*, double** %5
%321 = load i32, i32* %17
%322 = sext i32 %321 to i64
%323 = sub i64 0, %322
%324 = getelementptr inbounds double, double* %320, i64 %323
%325 = getelementptr inbounds double, double* %324, i64 -1
store double* %325, double** %55
%326 = load double*, double** %5
%327 = load i32, i32* %17
%328 = sext i32 %327 to i64
%329 = sub i64 0, %328
%330 = getelementptr inbounds double, double* %326, i64 %329
store double* %330, double** %56
%331 = load double*, double** %5
%332 = load i32, i32* %17
%333 = sext i32 %332 to i64
%334 = sub i64 0, %333
%335 = getelementptr inbounds double, double* %331, i64 %334
%336 = getelementptr inbounds double, double* %335, i64 1
store double* %336, double** %57
%337 = load double*, double** %5
%338 = getelementptr inbounds double, double* %337, i64 -1
store double* %338, double** %58
%339 = load double*, double** %5
store double* %339, double** %59
%340 = load double*, double** %5
%341 = getelementptr inbounds double, double* %340, i64 1
store double* %341, double** %60
%342 = load double*, double** %5
%343 = load i32, i32* %17
%344 = sext i32 %343 to i64
%345 = getelementptr inbounds double, double* %342, i64 %344
%346 = getelementptr inbounds double, double* %345, i64 -1
store double* %346, double** %61
%347 = load double*, double** %5
%348 = load i32, i32* %17
%349 = sext i32 %348 to i64
%350 = getelementptr inbounds double, double* %347, i64 %349
store double* %350, double** %62
%351 = load double*, double** %5
%352 = load i32, i32* %17
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds double, double* %351, i64 %353
%355 = getelementptr inbounds double, double* %354, i64 1
store double* %355, double** %63
%356 = load double*, double** %5
%357 = load i32, i32* %18
%358 = sext i32 %357 to i64
%359 = getelementptr inbounds double, double* %356, i64 %358
%360 = load i32, i32* %17
%361 = sext i32 %360 to i64
%362 = sub i64 0, %361
%363 = getelementptr inbounds double, double* %359, i64 %362
%364 = getelementptr inbounds double, double* %363, i64 -1
store double* %364, double** %64
%365 = load double*, double** %5
%366 = load i32, i32* %18
%367 = sext i32 %366 to i64
%368 = getelementptr inbounds double, double* %365, i64 %367
%369 = load i32, i32* %17
%370 = sext i32 %369 to i64
%371 = sub i64 0, %370
%372 = getelementptr inbounds double, double* %368, i64 %371
store double* %372, double** %65
%373 = load double*, double** %5
%374 = load i32, i32* %18
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds double, double* %373, i64 %375
%377 = load i32, i32* %17
%378 = sext i32 %377 to i64
%379 = sub i64 0, %378
%380 = getelementptr inbounds double, double* %376, i64 %379
%381 = getelementptr inbounds double, double* %380, i64 1
store double* %381, double** %66
%382 = load double*, double** %5
%383 = load i32, i32* %18
%384 = sext i32 %383 to i64
%385 = getelementptr inbounds double, double* %382, i64 %384
%386 = getelementptr inbounds double, double* %385, i64 -1
store double* %386, double** %67
%387 = load double*, double** %5
%388 = load i32, i32* %18
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds double, double* %387, i64 %389
store double* %390, double** %68
%391 = load double*, double** %5
%392 = load i32, i32* %18
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds double, double* %391, i64 %393
%395 = getelementptr inbounds double, double* %394, i64 1
store double* %395, double** %69
%396 = load double*, double** %5
%397 = load i32, i32* %18
%398 = sext i32 %397 to i64
%399 = getelementptr inbounds double, double* %396, i64 %398
%400 = load i32, i32* %17
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds double, double* %399, i64 %401
%403 = getelementptr inbounds double, double* %402, i64 -1
store double* %403, double** %70
%404 = load double*, double** %5
%405 = load i32, i32* %18
%406 = sext i32 %405 to i64
%407 = getelementptr inbounds double, double* %404, i64 %406
%408 = load i32, i32* %17
%409 = sext i32 %408 to i64
%410 = getelementptr inbounds double, double* %407, i64 %409
store double* %410, double** %71
%411 = load double*, double** %5
%412 = load i32, i32* %18
%413 = sext i32 %412 to i64
%414 = getelementptr inbounds double, double* %411, i64 %413
%415 = load i32, i32* %17
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds double, double* %414, i64 %416
%418 = getelementptr inbounds double, double* %417, i64 1
store double* %418, double** %72
store i32 2, i32* %10
br label %419
419: ; preds = %752, %3
%420 = load i32, i32* %10
%421 = load i32, i32* %16
%422 = icmp slt i32 %420, %421
br i1 %422, label %423, label %755
423: ; preds = %419
store i32 2, i32* %9
br label %424
424: ; preds = %748, %423
%425 = load i32, i32* %9
%426 = load i32, i32* %14
%427 = icmp slt i32 %425, %426
br i1 %427, label %428, label %751
428: ; preds = %424
store i32 2, i32* %8
br label %429
429: ; preds = %744, %428
%430 = load i32, i32* %8
%431 = load i32, i32* %12
%432 = icmp slt i32 %430, %431
br i1 %432, label %433, label %747
433: ; preds = %429
%434 = load i32, i32* %8
%435 = load i32, i32* %9
%436 = load i32, i32* %17
%437 = mul nsw i32 %435, %436
%438 = add nsw i32 %434, %437
%439 = load i32, i32* %10
%440 = load i32, i32* %18
%441 = mul nsw i32 %439, %440
%442 = add nsw i32 %438, %441
store i32 %442, i32* %7
%443 = load double*, double** %19
%444 = load i32, i32* %7
%445 = sext i32 %444 to i64
%446 = getelementptr inbounds double, double* %443, i64 %445
%447 = load double, double* %446
%448 = load double*, double** %46
%449 = load i32, i32* %7
%450 = sext i32 %449 to i64
%451 = getelementptr inbounds double, double* %448, i64 %450
%452 = load double, double* %451
%453 = load double*, double** %20
%454 = load i32, i32* %7
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds double, double* %453, i64 %455
%457 = load double, double* %456
%458 = load double*, double** %47
%459 = load i32, i32* %7
%460 = sext i32 %459 to i64
%461 = getelementptr inbounds double, double* %458, i64 %460
%462 = load double, double* %461
%463 = fmul double %457, %462
%464 = call double @llvm.fmuladd.f64(double %447, double %452, double %463)
%465 = load double*, double** %21
%466 = load i32, i32* %7
%467 = sext i32 %466 to i64
%468 = getelementptr inbounds double, double* %465, i64 %467
%469 = load double, double* %468
%470 = load double*, double** %48
%471 = load i32, i32* %7
%472 = sext i32 %471 to i64
%473 = getelementptr inbounds double, double* %470, i64 %472
%474 = load double, double* %473
%475 = call double @llvm.fmuladd.f64(double %469, double %474, double %464)
%476 = load double*, double** %22
%477 = load i32, i32* %7
%478 = sext i32 %477 to i64
%479 = getelementptr inbounds double, double* %476, i64 %478
%480 = load double, double* %479
%481 = load double*, double** %49
%482 = load i32, i32* %7
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds double, double* %481, i64 %483
%485 = load double, double* %484
%486 = call double @llvm.fmuladd.f64(double %480, double %485, double %475)
%487 = load double*, double** %23
%488 = load i32, i32* %7
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds double, double* %487, i64 %489
%491 = load double, double* %490
%492 = load double*, double** %50
%493 = load i32, i32* %7
%494 = sext i32 %493 to i64
%495 = getelementptr inbounds double, double* %492, i64 %494
%496 = load double, double* %495
%497 = call double @llvm.fmuladd.f64(double %491, double %496, double %486)
%498 = load double*, double** %24
%499 = load i32, i32* %7
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds double, double* %498, i64 %500
%502 = load double, double* %501
%503 = load double*, double** %51
%504 = load i32, i32* %7
%505 = sext i32 %504 to i64
%506 = getelementptr inbounds double, double* %503, i64 %505
%507 = load double, double* %506
%508 = call double @llvm.fmuladd.f64(double %502, double %507, double %497)
%509 = load double*, double** %25
%510 = load i32, i32* %7
%511 = sext i32 %510 to i64
%512 = getelementptr inbounds double, double* %509, i64 %511
%513 = load double, double* %512
%514 = load double*, double** %52
%515 = load i32, i32* %7
%516 = sext i32 %515 to i64
%517 = getelementptr inbounds double, double* %514, i64 %516
%518 = load double, double* %517
%519 = call double @llvm.fmuladd.f64(double %513, double %518, double %508)
%520 = load double*, double** %26
%521 = load i32, i32* %7
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds double, double* %520, i64 %522
%524 = load double, double* %523
%525 = load double*, double** %53
%526 = load i32, i32* %7
%527 = sext i32 %526 to i64
%528 = getelementptr inbounds double, double* %525, i64 %527
%529 = load double, double* %528
%530 = call double @llvm.fmuladd.f64(double %524, double %529, double %519)
%531 = load double*, double** %27
%532 = load i32, i32* %7
%533 = sext i32 %532 to i64
%534 = getelementptr inbounds double, double* %531, i64 %533
%535 = load double, double* %534
%536 = load double*, double** %54
%537 = load i32, i32* %7
%538 = sext i32 %537 to i64
%539 = getelementptr inbounds double, double* %536, i64 %538
%540 = load double, double* %539
%541 = call double @llvm.fmuladd.f64(double %535, double %540, double %530)
%542 = load double*, double** %28
%543 = load i32, i32* %7
%544 = sext i32 %543 to i64
%545 = getelementptr inbounds double, double* %542, i64 %544
%546 = load double, double* %545
%547 = load double*, double** %55
%548 = load i32, i32* %7
%549 = sext i32 %548 to i64
%550 = getelementptr inbounds double, double* %547, i64 %549
%551 = load double, double* %550
%552 = call double @llvm.fmuladd.f64(double %546, double %551, double %541)
%553 = load double*, double** %29
%554 = load i32, i32* %7
%555 = sext i32 %554 to i64
%556 = getelementptr inbounds double, double* %553, i64 %555
%557 = load double, double* %556
%558 = load double*, double** %56
%559 = load i32, i32* %7
%560 = sext i32 %559 to i64
%561 = getelementptr inbounds double, double* %558, i64 %560
%562 = load double, double* %561
%563 = call double @llvm.fmuladd.f64(double %557, double %562, double %552)
%564 = load double*, double** %30
%565 = load i32, i32* %7
%566 = sext i32 %565 to i64
%567 = getelementptr inbounds double, double* %564, i64 %566
%568 = load double, double* %567
%569 = load double*, double** %57
%570 = load i32, i32* %7
%571 = sext i32 %570 to i64
%572 = getelementptr inbounds double, double* %569, i64 %571
%573 = load double, double* %572
%574 = call double @llvm.fmuladd.f64(double %568, double %573, double %563)
%575 = load double*, double** %31
%576 = load i32, i32* %7
%577 = sext i32 %576 to i64
%578 = getelementptr inbounds double, double* %575, i64 %577
%579 = load double, double* %578
%580 = load double*, double** %58
%581 = load i32, i32* %7
%582 = sext i32 %581 to i64
%583 = getelementptr inbounds double, double* %580, i64 %582
%584 = load double, double* %583
%585 = call double @llvm.fmuladd.f64(double %579, double %584, double %574)
%586 = load double*, double** %32
%587 = load i32, i32* %7
%588 = sext i32 %587 to i64
%589 = getelementptr inbounds double, double* %586, i64 %588
%590 = load double, double* %589
%591 = load double*, double** %59
%592 = load i32, i32* %7
%593 = sext i32 %592 to i64
%594 = getelementptr inbounds double, double* %591, i64 %593
%595 = load double, double* %594
%596 = call double @llvm.fmuladd.f64(double %590, double %595, double %585)
%597 = load double*, double** %33
%598 = load i32, i32* %7
%599 = sext i32 %598 to i64
%600 = getelementptr inbounds double, double* %597, i64 %599
%601 = load double, double* %600
%602 = load double*, double** %60
%603 = load i32, i32* %7
%604 = sext i32 %603 to i64
%605 = getelementptr inbounds double, double* %602, i64 %604
%606 = load double, double* %605
%607 = call double @llvm.fmuladd.f64(double %601, double %606, double %596)
%608 = load double*, double** %34
%609 = load i32, i32* %7
%610 = sext i32 %609 to i64
%611 = getelementptr inbounds double, double* %608, i64 %610
%612 = load double, double* %611
%613 = load double*, double** %61
%614 = load i32, i32* %7
%615 = sext i32 %614 to i64
%616 = getelementptr inbounds double, double* %613, i64 %615
%617 = load double, double* %616
%618 = call double @llvm.fmuladd.f64(double %612, double %617, double %607)
%619 = load double*, double** %35
%620 = load i32, i32* %7
%621 = sext i32 %620 to i64
%622 = getelementptr inbounds double, double* %619, i64 %621
%623 = load double, double* %622
%624 = load double*, double** %62
%625 = load i32, i32* %7
%626 = sext i32 %625 to i64
%627 = getelementptr inbounds double, double* %624, i64 %626
%628 = load double, double* %627
%629 = call double @llvm.fmuladd.f64(double %623, double %628, double %618)
%630 = load double*, double** %36
%631 = load i32, i32* %7
%632 = sext i32 %631 to i64
%633 = getelementptr inbounds double, double* %630, i64 %632
%634 = load double, double* %633
%635 = load double*, double** %63
%636 = load i32, i32* %7
%637 = sext i32 %636 to i64
%638 = getelementptr inbounds double, double* %635, i64 %637
%639 = load double, double* %638
%640 = call double @llvm.fmuladd.f64(double %634, double %639, double %629)
%641 = load double*, double** %37
%642 = load i32, i32* %7
%643 = sext i32 %642 to i64
%644 = getelementptr inbounds double, double* %641, i64 %643
%645 = load double, double* %644
%646 = load double*, double** %64
%647 = load i32, i32* %7
%648 = sext i32 %647 to i64
%649 = getelementptr inbounds double, double* %646, i64 %648
%650 = load double, double* %649
%651 = call double @llvm.fmuladd.f64(double %645, double %650, double %640)
%652 = load double*, double** %38
%653 = load i32, i32* %7
%654 = sext i32 %653 to i64
%655 = getelementptr inbounds double, double* %652, i64 %654
%656 = load double, double* %655
%657 = load double*, double** %65
%658 = load i32, i32* %7
%659 = sext i32 %658 to i64
%660 = getelementptr inbounds double, double* %657, i64 %659
%661 = load double, double* %660
%662 = call double @llvm.fmuladd.f64(double %656, double %661, double %651)
%663 = load double*, double** %39
%664 = load i32, i32* %7
%665 = sext i32 %664 to i64
%666 = getelementptr inbounds double, double* %663, i64 %665
%667 = load double, double* %666
%668 = load double*, double** %66
%669 = load i32, i32* %7
%670 = sext i32 %669 to i64
%671 = getelementptr inbounds double, double* %668, i64 %670
%672 = load double, double* %671
%673 = call double @llvm.fmuladd.f64(double %667, double %672, double %662)
%674 = load double*, double** %40
%675 = load i32, i32* %7
%676 = sext i32 %675 to i64
%677 = getelementptr inbounds double, double* %674, i64 %676
%678 = load double, double* %677
%679 = load double*, double** %67
%680 = load i32, i32* %7
%681 = sext i32 %680 to i64
%682 = getelementptr inbounds double, double* %679, i64 %681
%683 = load double, double* %682
%684 = call double @llvm.fmuladd.f64(double %678, double %683, double %673)
%685 = load double*, double** %41
%686 = load i32, i32* %7
%687 = sext i32 %686 to i64
%688 = getelementptr inbounds double, double* %685, i64 %687
%689 = load double, double* %688
%690 = load double*, double** %68
%691 = load i32, i32* %7
%692 = sext i32 %691 to i64
%693 = getelementptr inbounds double, double* %690, i64 %692
%694 = load double, double* %693
%695 = call double @llvm.fmuladd.f64(double %689, double %694, double %684)
%696 = load double*, double** %42
%697 = load i32, i32* %7
%698 = sext i32 %697 to i64
%699 = getelementptr inbounds double, double* %696, i64 %698
%700 = load double, double* %699
%701 = load double*, double** %69
%702 = load i32, i32* %7
%703 = sext i32 %702 to i64
%704 = getelementptr inbounds double, double* %701, i64 %703
%705 = load double, double* %704
%706 = call double @llvm.fmuladd.f64(double %700, double %705, double %695)
%707 = load double*, double** %43
%708 = load i32, i32* %7
%709 = sext i32 %708 to i64
%710 = getelementptr inbounds double, double* %707, i64 %709
%711 = load double, double* %710
%712 = load double*, double** %70
%713 = load i32, i32* %7
%714 = sext i32 %713 to i64
%715 = getelementptr inbounds double, double* %712, i64 %714
%716 = load double, double* %715
%717 = call double @llvm.fmuladd.f64(double %711, double %716, double %706)
%718 = load double*, double** %44
%719 = load i32, i32* %7
%720 = sext i32 %719 to i64
%721 = getelementptr inbounds double, double* %718, i64 %720
%722 = load double, double* %721
%723 = load double*, double** %71
%724 = load i32, i32* %7
%725 = sext i32 %724 to i64
%726 = getelementptr inbounds double, double* %723, i64 %725
%727 = load double, double* %726
%728 = call double @llvm.fmuladd.f64(double %722, double %727, double %717)
%729 = load double*, double** %45
%730 = load i32, i32* %7
%731 = sext i32 %730 to i64
%732 = getelementptr inbounds double, double* %729, i64 %731
%733 = load double, double* %732
%734 = load double*, double** %72
%735 = load i32, i32* %7
%736 = sext i32 %735 to i64
%737 = getelementptr inbounds double, double* %734, i64 %736
%738 = load double, double* %737
%739 = call double @llvm.fmuladd.f64(double %733, double %738, double %728)
%740 = load double*, double** %6
%741 = load i32, i32* %7
%742 = sext i32 %741 to i64
%743 = getelementptr inbounds double, double* %740, i64 %742
store double %739, double* %743
br label %744
744: ; preds = %433
%745 = load i32, i32* %8
%746 = add nsw i32 %745, 1
store i32 %746, i32* %8
br label %429
747: ; preds = %429
br label %748
748: ; preds = %747
%749 = load i32, i32* %9
%750 = add nsw i32 %749, 1
store i32 %750, i32* %9
br label %424
751: ; preds = %424
br label %752
752: ; preds = %751
%753 = load i32, i32* %10
%754 = add nsw i32 %753, 1
store i32 %754, i32* %10
br label %419
755: ; preds = %419
ret void
}

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