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