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


x86 assembly (clang, -O0):
<rmatmult_3_at>:
push   %rbp
mov    %rsp,%rbp
sub    $0x1a8,%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
mov    -0x48(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    -0x44(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x128(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    -0x44(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x130(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    -0x44(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
add    $0x8,%rax
mov    %rax,-0x138(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x140(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x148(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
add    $0x8,%rax
mov    %rax,-0x150(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    -0x44(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x158(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    -0x44(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x160(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    -0x44(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
add    $0x8,%rax
mov    %rax,-0x168(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x170(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x178(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%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
mov    -0x44(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x1a0(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x1a8(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x44(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
add    $0x8,%rax
mov    %rax,-0x1b0(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    -0x44(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x1b8(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    -0x44(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x1c0(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    -0x44(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
add    $0x8,%rax
mov    %rax,-0x1c8(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x1d0(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x1d8(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
add    $0x8,%rax
mov    %rax,-0x1e0(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    -0x44(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x1e8(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    -0x44(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x1f0(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    -0x44(%rbp),%ecx
shl    $0x3,%ecx
movslq %ecx,%rcx
add    %rcx,%rax
add    $0x8,%rax
mov    %rax,-0x1f8(%rbp)
movl   $0x2,-0x1fc(%rbp)
mov    -0x1fc(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1d60 <rmatmult_3_at+0xc60>
movl   $0x2,-0x200(%rbp)
mov    -0x200(%rbp),%eax
mov    -0x40(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1d47 <rmatmult_3_at+0xc47>
movl   $0x2,-0x204(%rbp)
mov    -0x204(%rbp),%eax
mov    -0x38(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jg     1d2e <rmatmult_3_at+0xc2e>
mov    -0x200(%rbp),%eax
mov    %eax,-0x208(%rbp)
mov    -0x208(%rbp),%eax
mov    %eax,-0x214(%rbp)
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
mov    -0x200(%rbp),%ecx
add    $0x46,%ecx
cmp    %ecx,%eax
jge    179d <rmatmult_3_at+0x69d>
mov    -0x40(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x218(%rbp)
jmp    17ac <rmatmult_3_at+0x6ac>
mov    -0x200(%rbp),%eax
add    $0x46,%eax
mov    %eax,-0x218(%rbp)
mov    -0x214(%rbp),%eax
mov    -0x218(%rbp),%ecx
cmp    %ecx,%eax
jg     1d15 <rmatmult_3_at+0xc15>
mov    -0x204(%rbp),%eax
mov    %eax,-0x20c(%rbp)
mov    -0x20c(%rbp),%eax
mov    %eax,-0x21c(%rbp)
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
mov    -0x204(%rbp),%ecx
add    $0xe,%ecx
cmp    %ecx,%eax
jge    1800 <rmatmult_3_at+0x700>
mov    -0x38(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x220(%rbp)
jmp    180f <rmatmult_3_at+0x70f>
mov    -0x204(%rbp),%eax
add    $0xe,%eax
mov    %eax,-0x220(%rbp)
mov    -0x21c(%rbp),%eax
mov    -0x220(%rbp),%ecx
cmp    %ecx,%eax
jg     1cfc <rmatmult_3_at+0xbfc>
mov    -0x1fc(%rbp),%eax
mov    %eax,-0x210(%rbp)
mov    -0x210(%rbp),%eax
mov    %eax,-0x224(%rbp)
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
mov    -0x1fc(%rbp),%ecx
add    $0x35,%ecx
cmp    %ecx,%eax
jge    1863 <rmatmult_3_at+0x763>
mov    -0x30(%rbp),%eax
sub    $0x1,%eax
mov    %eax,-0x228(%rbp)
jmp    1872 <rmatmult_3_at+0x772>
mov    -0x1fc(%rbp),%eax
add    $0x35,%eax
mov    %eax,-0x228(%rbp)
mov    -0x224(%rbp),%eax
mov    -0x228(%rbp),%ecx
cmp    %ecx,%eax
jg     1ce3 <rmatmult_3_at+0xbe3>
mov    -0x210(%rbp),%eax
mov    -0x20c(%rbp),%ecx
imul   -0x44(%rbp),%ecx
add    %ecx,%eax
mov    -0x208(%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    -0x210(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x210(%rbp)
jmp    182f <rmatmult_3_at+0x72f>
jmp    1ce8 <rmatmult_3_at+0xbe8>
mov    -0x20c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x20c(%rbp)
jmp    17cc <rmatmult_3_at+0x6cc>
jmp    1d01 <rmatmult_3_at+0xc01>
mov    -0x208(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x208(%rbp)
jmp    1769 <rmatmult_3_at+0x669>
jmp    1d1a <rmatmult_3_at+0xc1a>
mov    -0x204(%rbp),%eax
add    $0xf,%eax
mov    %eax,-0x204(%rbp)
jmp    1749 <rmatmult_3_at+0x649>
jmp    1d33 <rmatmult_3_at+0xc33>
mov    -0x200(%rbp),%eax
add    $0x47,%eax
mov    %eax,-0x200(%rbp)
jmp    172b <rmatmult_3_at+0x62b>
jmp    1d4c <rmatmult_3_at+0xc4c>
mov    -0x1fc(%rbp),%eax
add    $0x36,%eax
mov    %eax,-0x1fc(%rbp)
jmp    170d <rmatmult_3_at+0x60d>
add    $0x1a8,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<rmatmult_3_at>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x118,%rsp
mov    %rdx,0x100(%rsp)
mov    %rsi,-0x10(%rsp)
mov    0x8(%rdi),%rax
mov    (%rax),%eax
mov    %rax,-0x30(%rsp)
cmp    $0x3,%eax
jl     17fe <rmatmult_3_at+0x6fe>
mov    %rdi,%r9
mov    0x18(%rdi),%rax
mov    (%rax),%ebx
mov    0x28(%rdi),%rax
mov    (%rax),%esi
mov    0x30(%rdi),%rax
movslq (%rax),%rdi
mov    0x38(%r9),%rax
movslq (%rax),%r10
mov    0x40(%r9),%rax
mov    (%rax),%rax
mov    %rax,0x30(%rsp)
mov    0x48(%r9),%rax
mov    (%rax),%rax
mov    %rax,0x28(%rsp)
mov    0x50(%r9),%rax
mov    (%rax),%rax
mov    %rax,0x20(%rsp)
mov    0x58(%r9),%rax
mov    (%rax),%rax
mov    %rax,0x18(%rsp)
lea    0x0(,%r10,8),%rcx
mov    -0x10(%rsp),%rbp
mov    %rbp,%rdx
sub    %rcx,%rdx
lea    0x0(,%rdi,8),%rcx
mov    %rdx,%r14
sub    %rcx,%r14
mov    %rbp,%rax
sub    %rcx,%rax
mov    %rax,0x50(%rsp)
lea    0x0(,%r10,8),%rax
add    %rbp,%rax
mov    %rax,%r8
sub    %rcx,%r8
mov    0x60(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,-0x8(%rsp)
mov    0x68(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,0xf8(%rsp)
mov    0x70(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,0xf0(%rsp)
mov    0x78(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,0xe8(%rsp)
mov    0x80(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,0xe0(%rsp)
mov    0x88(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,0xd8(%rsp)
mov    0x90(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,0xd0(%rsp)
mov    0x98(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,0xc8(%rsp)
mov    0xa0(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,0xc0(%rsp)
mov    0xa8(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,0xb8(%rsp)
mov    0xb0(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,0x10(%rsp)
mov    0xb8(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,0xb0(%rsp)
mov    0xc0(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,0xa8(%rsp)
mov    0xc8(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,0xa0(%rsp)
mov    0xd0(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,0x98(%rsp)
mov    0xd8(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,0x90(%rsp)
mov    0xe0(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,0x88(%rsp)
mov    0xe8(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,0x80(%rsp)
mov    0xf0(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,0x78(%rsp)
mov    0xf8(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,0x70(%rsp)
mov    0x100(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,0x68(%rsp)
mov    0x108(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,0x60(%rsp)
mov    0x110(%r9),%rcx
mov    (%rcx),%rcx
mov    %rcx,0x58(%rsp)
lea    (%rdi,%rdi,1),%ecx
lea    0x2(%rcx,%r10,2),%ecx
mov    %ecx,-0x5c(%rsp)
lea    (%rdi,%rdi,4),%ecx
lea    (%rcx,%rcx,2),%ecx
mov    %ecx,-0x38(%rsp)
lea    (%rdx,%rdi,8),%r15
lea    0x0(%rbp,%rdi,8),%r12
mov    %rdi,0x38(%rsp)
mov    %rax,0x48(%rsp)
lea    (%rax,%rdi,8),%r13
mov    -0x30(%rsp),%rcx
add    $0xffffffff,%ecx
mov    %ecx,-0x48(%rsp)
mov    %rsi,-0x28(%rsp)
lea    -0x1(%rsi),%ecx
mov    %ecx,-0x44(%rsp)
mov    %rbx,-0x20(%rsp)
lea    -0x1(%rbx),%ecx
mov    %ecx,-0x3c(%rsp)
mov    %r10,(%rsp)
imul   $0x47,%r10d,%ecx
mov    %ecx,-0x40(%rsp)
mov    $0x2,%ecx
mov    %rcx,-0x50(%rsp)
mov    $0x1,%ecx
mov    %rcx,-0x18(%rsp)
mov    0x28(%rsp),%rax
mov    0x20(%rsp),%rsi
mov    0x18(%rsp),%rbx
mov    0x10(%rsp),%r9
jmp    13e3 <rmatmult_3_at+0x2e3>
mov    -0x50(%rsp),%rcx
add    $0x36,%rcx
addq   $0x36,-0x18(%rsp)
addl   $0x36,-0x5c(%rsp)
mov    %rcx,-0x50(%rsp)
cmp    %ecx,-0x30(%rsp)
jle    17fe <rmatmult_3_at+0x6fe>
cmpl   $0x3,-0x28(%rsp)
jl     13c0 <rmatmult_3_at+0x2c0>
mov    -0x50(%rsp),%rcx
lea    0x35(%rcx),%edi
mov    -0x48(%rsp),%ecx
cmp    %edi,%ecx
cmovl  %ecx,%edi
mov    %edi,-0x34(%rsp)
movslq %edi,%rcx
mov    %rcx,0x108(%rsp)
mov    $0x2,%ecx
mov    %rcx,-0x70(%rsp)
mov    -0x5c(%rsp),%ecx
mov    %ecx,-0x80(%rsp)
jmp    143f <rmatmult_3_at+0x33f>
xchg   %ax,%ax
mov    -0x70(%rsp),%rcx
add    $0x47,%ecx
mov    -0x80(%rsp),%edi
add    -0x40(%rsp),%edi
mov    %edi,-0x80(%rsp)
mov    %rcx,-0x70(%rsp)
cmp    -0x28(%rsp),%ecx
jge    13c0 <rmatmult_3_at+0x2c0>
cmpl   $0x3,-0x20(%rsp)
jl     1420 <rmatmult_3_at+0x320>
mov    -0x70(%rsp),%rcx
lea    0x46(%rcx),%edi
mov    -0x44(%rsp),%ecx
cmp    %edi,%ecx
cmovl  %ecx,%edi
mov    %edi,-0x58(%rsp)
mov    $0x2,%ecx
mov    %rcx,-0x68(%rsp)
mov    -0x80(%rsp),%ecx
mov    %ecx,-0x7c(%rsp)
jmp    148f <rmatmult_3_at+0x38f>
nop
mov    -0x68(%rsp),%rcx
add    $0xf,%ecx
mov    -0x7c(%rsp),%edi
add    -0x38(%rsp),%edi
mov    %edi,-0x7c(%rsp)
mov    %rcx,-0x68(%rsp)
cmp    -0x20(%rsp),%ecx
jge    1420 <rmatmult_3_at+0x320>
mov    -0x58(%rsp),%ecx
cmp    %ecx,-0x70(%rsp)
jg     1470 <rmatmult_3_at+0x370>
mov    -0x68(%rsp),%rcx
lea    0xe(%rcx),%edi
mov    -0x3c(%rsp),%ecx
cmp    %edi,%ecx
cmovl  %ecx,%edi
mov    %edi,-0x54(%rsp)
mov    -0x7c(%rsp),%ecx
mov    %ecx,-0x78(%rsp)
mov    -0x70(%rsp),%rcx
jmp    14dd <rmatmult_3_at+0x3dd>
nopl   (%rax)
mov    0x8(%rsp),%rdi
lea    0x1(%rdi),%r10d
mov    -0x78(%rsp),%ecx
add    (%rsp),%ecx
mov    %ecx,-0x78(%rsp)
cmp    -0x58(%rsp),%edi
mov    %r10d,%ecx
jge    1470 <rmatmult_3_at+0x370>
mov    %rcx,0x8(%rsp)
mov    -0x54(%rsp),%ecx
cmp    %ecx,-0x68(%rsp)
jg     14c0 <rmatmult_3_at+0x3c0>
mov    -0x78(%rsp),%ecx
mov    %ecx,-0x74(%rsp)
mov    -0x68(%rsp),%rcx
jmp    151e <rmatmult_3_at+0x41e>
nopl   0x0(%rax,%rax,1)
mov    0x40(%rsp),%rdi
lea    0x1(%rdi),%r10d
mov    -0x74(%rsp),%ecx
add    0x38(%rsp),%ecx
mov    %ecx,-0x74(%rsp)
cmp    -0x54(%rsp),%edi
mov    %r10d,%ecx
jge    14c0 <rmatmult_3_at+0x3c0>
mov    %rcx,0x40(%rsp)
mov    -0x34(%rsp),%ecx
cmp    -0x50(%rsp),%ecx
mov    0x30(%rsp),%rcx
mov    -0x8(%rsp),%r10
jl     1500 <rmatmult_3_at+0x400>
mov    -0x74(%rsp),%edi
mov    -0x18(%rsp),%rbp
mov    %rbp,0x110(%rsp)
movslq %edi,%rdi
movsd  (%rax,%rdi,8),%xmm0
mov    %r14,%r11
mulsd  (%r14,%rdi,8),%xmm0
movsd  (%rcx,%rdi,8),%xmm1
mulsd  -0x8(%r14,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  (%rsi,%rdi,8),%xmm0
mulsd  0x8(%r14,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
movsd  (%rbx,%rdi,8),%xmm1
mulsd  -0x8(%rdx,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  (%r10,%rdi,8),%xmm0
mulsd  (%rdx,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
mov    0xf8(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  0x8(%rdx,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
mov    0xf0(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm0
mulsd  -0x8(%r15,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
mov    0xe8(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  (%r15,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
mov    0xe0(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm0
mulsd  0x8(%r15,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
mov    0xd8(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm1
mov    0x50(%rsp),%r10
mulsd  -0x8(%r10,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
mov    0xd0(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm0
mulsd  (%r10,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
mov    0xc8(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  0x8(%r10,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
mov    0xc0(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm0
mov    -0x10(%rsp),%r10
mulsd  -0x8(%r10,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
mov    0xb8(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  (%r10,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
movsd  (%r9,%rdi,8),%xmm0
mulsd  0x8(%r10,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
mov    0xb0(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  -0x8(%r12,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
mov    0xa8(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm0
mulsd  (%r12,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
mov    0xa0(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  0x8(%r12,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x98(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm0
mulsd  -0x8(%r8,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
mov    0x90(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  (%r8,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x88(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm0
mulsd  0x8(%r8,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
mov    0x80(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm1
mov    0x48(%rsp),%r10
mulsd  -0x8(%r10,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x78(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm0
mulsd  (%r10,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
mov    0x70(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  0x8(%r10,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x68(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm0
mulsd  -0x8(%r13,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
mov    0x60(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm1
mulsd  0x0(%r13,%rdi,8),%xmm1
addsd  %xmm0,%xmm1
mov    0x58(%rsp),%rbp
movsd  0x0(%rbp,%rdi,8),%xmm0
mulsd  0x8(%r13,%rdi,8),%xmm0
addsd  %xmm1,%xmm0
mov    %r13,%r10
mov    %r12,%r13
mov    %r15,%r12
mov    %r8,%r15
mov    0x100(%rsp),%r14
movsd  %xmm0,(%r14,%rdi,8)
mov    %r11,%r14
mov    0x108(%rsp),%r11
mov    0x110(%rsp),%rbp
mov    %r12,%r15
mov    %r13,%r12
mov    %r10,%r13
mov    -0x8(%rsp),%r10
add    $0x1,%rbp
add    $0x1,%edi
cmp    %r11,%rbp
jl     1540 <rmatmult_3_at+0x440>
jmp    1500 <rmatmult_3_at+0x400>
add    $0x118,%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 i32
%74 = alloca i32
%75 = alloca i32
%76 = alloca i32
%77 = alloca i32
%78 = alloca i32
store i8** %0, i8*** %4
store double* %1, double** %5
store double* %2, double** %6
%79 = load i8**, i8*** %4
%80 = load i8*, i8** %79
%81 = bitcast i8* %80 to i32*
%82 = load i32, i32* %81
store i32 %82, i32* %11
%83 = load i8**, i8*** %4
%84 = getelementptr inbounds i8*, i8** %83, i64 1
%85 = load i8*, i8** %84
%86 = bitcast i8* %85 to i32*
%87 = load i32, i32* %86
store i32 %87, i32* %12
%88 = load i8**, i8*** %4
%89 = getelementptr inbounds i8*, i8** %88, i64 2
%90 = load i8*, i8** %89
%91 = bitcast i8* %90 to i32*
%92 = load i32, i32* %91
store i32 %92, i32* %13
%93 = load i8**, i8*** %4
%94 = getelementptr inbounds i8*, i8** %93, i64 3
%95 = load i8*, i8** %94
%96 = bitcast i8* %95 to i32*
%97 = load i32, i32* %96
store i32 %97, i32* %14
%98 = load i8**, i8*** %4
%99 = getelementptr inbounds i8*, i8** %98, i64 4
%100 = load i8*, i8** %99
%101 = bitcast i8* %100 to i32*
%102 = load i32, i32* %101
store i32 %102, i32* %15
%103 = load i8**, i8*** %4
%104 = getelementptr inbounds i8*, i8** %103, i64 5
%105 = load i8*, i8** %104
%106 = bitcast i8* %105 to i32*
%107 = load i32, i32* %106
store i32 %107, i32* %16
%108 = load i8**, i8*** %4
%109 = getelementptr inbounds i8*, i8** %108, i64 6
%110 = load i8*, i8** %109
%111 = bitcast i8* %110 to i32*
%112 = load i32, i32* %111
store i32 %112, i32* %17
%113 = load i8**, i8*** %4
%114 = getelementptr inbounds i8*, i8** %113, i64 7
%115 = load i8*, i8** %114
%116 = bitcast i8* %115 to i32*
%117 = load i32, i32* %116
store i32 %117, i32* %18
%118 = load i8**, i8*** %4
%119 = getelementptr inbounds i8*, i8** %118, i64 8
%120 = load i8*, i8** %119
%121 = bitcast i8* %120 to double**
%122 = load double*, double** %121
store double* %122, double** %19
%123 = load i8**, i8*** %4
%124 = getelementptr inbounds i8*, i8** %123, i64 9
%125 = load i8*, i8** %124
%126 = bitcast i8* %125 to double**
%127 = load double*, double** %126
store double* %127, double** %20
%128 = load i8**, i8*** %4
%129 = getelementptr inbounds i8*, i8** %128, i64 10
%130 = load i8*, i8** %129
%131 = bitcast i8* %130 to double**
%132 = load double*, double** %131
store double* %132, double** %21
%133 = load i8**, i8*** %4
%134 = getelementptr inbounds i8*, i8** %133, i64 11
%135 = load i8*, i8** %134
%136 = bitcast i8* %135 to double**
%137 = load double*, double** %136
store double* %137, double** %22
%138 = load i8**, i8*** %4
%139 = getelementptr inbounds i8*, i8** %138, i64 12
%140 = load i8*, i8** %139
%141 = bitcast i8* %140 to double**
%142 = load double*, double** %141
store double* %142, double** %23
%143 = load i8**, i8*** %4
%144 = getelementptr inbounds i8*, i8** %143, i64 13
%145 = load i8*, i8** %144
%146 = bitcast i8* %145 to double**
%147 = load double*, double** %146
store double* %147, double** %24
%148 = load i8**, i8*** %4
%149 = getelementptr inbounds i8*, i8** %148, i64 14
%150 = load i8*, i8** %149
%151 = bitcast i8* %150 to double**
%152 = load double*, double** %151
store double* %152, double** %25
%153 = load i8**, i8*** %4
%154 = getelementptr inbounds i8*, i8** %153, i64 15
%155 = load i8*, i8** %154
%156 = bitcast i8* %155 to double**
%157 = load double*, double** %156
store double* %157, double** %26
%158 = load i8**, i8*** %4
%159 = getelementptr inbounds i8*, i8** %158, i64 16
%160 = load i8*, i8** %159
%161 = bitcast i8* %160 to double**
%162 = load double*, double** %161
store double* %162, double** %27
%163 = load i8**, i8*** %4
%164 = getelementptr inbounds i8*, i8** %163, i64 17
%165 = load i8*, i8** %164
%166 = bitcast i8* %165 to double**
%167 = load double*, double** %166
store double* %167, double** %28
%168 = load i8**, i8*** %4
%169 = getelementptr inbounds i8*, i8** %168, i64 18
%170 = load i8*, i8** %169
%171 = bitcast i8* %170 to double**
%172 = load double*, double** %171
store double* %172, double** %29
%173 = load i8**, i8*** %4
%174 = getelementptr inbounds i8*, i8** %173, i64 19
%175 = load i8*, i8** %174
%176 = bitcast i8* %175 to double**
%177 = load double*, double** %176
store double* %177, double** %30
%178 = load i8**, i8*** %4
%179 = getelementptr inbounds i8*, i8** %178, i64 20
%180 = load i8*, i8** %179
%181 = bitcast i8* %180 to double**
%182 = load double*, double** %181
store double* %182, double** %31
%183 = load i8**, i8*** %4
%184 = getelementptr inbounds i8*, i8** %183, i64 21
%185 = load i8*, i8** %184
%186 = bitcast i8* %185 to double**
%187 = load double*, double** %186
store double* %187, double** %32
%188 = load i8**, i8*** %4
%189 = getelementptr inbounds i8*, i8** %188, i64 22
%190 = load i8*, i8** %189
%191 = bitcast i8* %190 to double**
%192 = load double*, double** %191
store double* %192, double** %33
%193 = load i8**, i8*** %4
%194 = getelementptr inbounds i8*, i8** %193, i64 23
%195 = load i8*, i8** %194
%196 = bitcast i8* %195 to double**
%197 = load double*, double** %196
store double* %197, double** %34
%198 = load i8**, i8*** %4
%199 = getelementptr inbounds i8*, i8** %198, i64 24
%200 = load i8*, i8** %199
%201 = bitcast i8* %200 to double**
%202 = load double*, double** %201
store double* %202, double** %35
%203 = load i8**, i8*** %4
%204 = getelementptr inbounds i8*, i8** %203, i64 25
%205 = load i8*, i8** %204
%206 = bitcast i8* %205 to double**
%207 = load double*, double** %206
store double* %207, double** %36
%208 = load i8**, i8*** %4
%209 = getelementptr inbounds i8*, i8** %208, i64 26
%210 = load i8*, i8** %209
%211 = bitcast i8* %210 to double**
%212 = load double*, double** %211
store double* %212, double** %37
%213 = load i8**, i8*** %4
%214 = getelementptr inbounds i8*, i8** %213, i64 27
%215 = load i8*, i8** %214
%216 = bitcast i8* %215 to double**
%217 = load double*, double** %216
store double* %217, double** %38
%218 = load i8**, i8*** %4
%219 = getelementptr inbounds i8*, i8** %218, i64 28
%220 = load i8*, i8** %219
%221 = bitcast i8* %220 to double**
%222 = load double*, double** %221
store double* %222, double** %39
%223 = load i8**, i8*** %4
%224 = getelementptr inbounds i8*, i8** %223, i64 29
%225 = load i8*, i8** %224
%226 = bitcast i8* %225 to double**
%227 = load double*, double** %226
store double* %227, double** %40
%228 = load i8**, i8*** %4
%229 = getelementptr inbounds i8*, i8** %228, i64 30
%230 = load i8*, i8** %229
%231 = bitcast i8* %230 to double**
%232 = load double*, double** %231
store double* %232, double** %41
%233 = load i8**, i8*** %4
%234 = getelementptr inbounds i8*, i8** %233, i64 31
%235 = load i8*, i8** %234
%236 = bitcast i8* %235 to double**
%237 = load double*, double** %236
store double* %237, double** %42
%238 = load i8**, i8*** %4
%239 = getelementptr inbounds i8*, i8** %238, i64 32
%240 = load i8*, i8** %239
%241 = bitcast i8* %240 to double**
%242 = load double*, double** %241
store double* %242, double** %43
%243 = load i8**, i8*** %4
%244 = getelementptr inbounds i8*, i8** %243, i64 33
%245 = load i8*, i8** %244
%246 = bitcast i8* %245 to double**
%247 = load double*, double** %246
store double* %247, double** %44
%248 = load i8**, i8*** %4
%249 = getelementptr inbounds i8*, i8** %248, i64 34
%250 = load i8*, i8** %249
%251 = bitcast i8* %250 to double**
%252 = load double*, double** %251
store double* %252, double** %45
%253 = load double*, double** %5
%254 = bitcast double* %253 to i8*
%255 = load i32, i32* %18
%256 = mul nsw i32 8, %255
%257 = sext i32 %256 to i64
%258 = sub i64 0, %257
%259 = getelementptr inbounds i8, i8* %254, i64 %258
%260 = load i32, i32* %17
%261 = mul nsw i32 8, %260
%262 = sext i32 %261 to i64
%263 = sub i64 0, %262
%264 = getelementptr inbounds i8, i8* %259, i64 %263
%265 = bitcast i8* %264 to double*
%266 = getelementptr inbounds double, double* %265, i64 -1
store double* %266, double** %46
%267 = load double*, double** %5
%268 = bitcast double* %267 to i8*
%269 = load i32, i32* %18
%270 = mul nsw i32 8, %269
%271 = sext i32 %270 to i64
%272 = sub i64 0, %271
%273 = getelementptr inbounds i8, i8* %268, i64 %272
%274 = load i32, i32* %17
%275 = mul nsw i32 8, %274
%276 = sext i32 %275 to i64
%277 = sub i64 0, %276
%278 = getelementptr inbounds i8, i8* %273, i64 %277
%279 = bitcast i8* %278 to double*
store double* %279, double** %47
%280 = load double*, double** %5
%281 = bitcast double* %280 to i8*
%282 = load i32, i32* %18
%283 = mul nsw i32 8, %282
%284 = sext i32 %283 to i64
%285 = sub i64 0, %284
%286 = getelementptr inbounds i8, i8* %281, i64 %285
%287 = load i32, i32* %17
%288 = mul nsw i32 8, %287
%289 = sext i32 %288 to i64
%290 = sub i64 0, %289
%291 = getelementptr inbounds i8, i8* %286, i64 %290
%292 = bitcast i8* %291 to double*
%293 = getelementptr inbounds double, double* %292, i64 1
store double* %293, double** %48
%294 = load double*, double** %5
%295 = bitcast double* %294 to i8*
%296 = load i32, i32* %18
%297 = mul nsw i32 8, %296
%298 = sext i32 %297 to i64
%299 = sub i64 0, %298
%300 = getelementptr inbounds i8, i8* %295, i64 %299
%301 = bitcast i8* %300 to double*
%302 = getelementptr inbounds double, double* %301, i64 -1
store double* %302, double** %49
%303 = load double*, double** %5
%304 = bitcast double* %303 to i8*
%305 = load i32, i32* %18
%306 = mul nsw i32 8, %305
%307 = sext i32 %306 to i64
%308 = sub i64 0, %307
%309 = getelementptr inbounds i8, i8* %304, i64 %308
%310 = bitcast i8* %309 to double*
store double* %310, double** %50
%311 = load double*, double** %5
%312 = bitcast double* %311 to i8*
%313 = load i32, i32* %18
%314 = mul nsw i32 8, %313
%315 = sext i32 %314 to i64
%316 = sub i64 0, %315
%317 = getelementptr inbounds i8, i8* %312, i64 %316
%318 = bitcast i8* %317 to double*
%319 = getelementptr inbounds double, double* %318, i64 1
store double* %319, double** %51
%320 = load double*, double** %5
%321 = bitcast double* %320 to i8*
%322 = load i32, i32* %18
%323 = mul nsw i32 8, %322
%324 = sext i32 %323 to i64
%325 = sub i64 0, %324
%326 = getelementptr inbounds i8, i8* %321, i64 %325
%327 = load i32, i32* %17
%328 = mul nsw i32 8, %327
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds i8, i8* %326, i64 %329
%331 = bitcast i8* %330 to double*
%332 = getelementptr inbounds double, double* %331, i64 -1
store double* %332, double** %52
%333 = load double*, double** %5
%334 = bitcast double* %333 to i8*
%335 = load i32, i32* %18
%336 = mul nsw i32 8, %335
%337 = sext i32 %336 to i64
%338 = sub i64 0, %337
%339 = getelementptr inbounds i8, i8* %334, i64 %338
%340 = load i32, i32* %17
%341 = mul nsw i32 8, %340
%342 = sext i32 %341 to i64
%343 = getelementptr inbounds i8, i8* %339, i64 %342
%344 = bitcast i8* %343 to double*
store double* %344, double** %53
%345 = load double*, double** %5
%346 = bitcast double* %345 to i8*
%347 = load i32, i32* %18
%348 = mul nsw i32 8, %347
%349 = sext i32 %348 to i64
%350 = sub i64 0, %349
%351 = getelementptr inbounds i8, i8* %346, i64 %350
%352 = load i32, i32* %17
%353 = mul nsw i32 8, %352
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds i8, i8* %351, i64 %354
%356 = bitcast i8* %355 to double*
%357 = getelementptr inbounds double, double* %356, i64 1
store double* %357, double** %54
%358 = load double*, double** %5
%359 = bitcast double* %358 to i8*
%360 = load i32, i32* %17
%361 = mul nsw i32 8, %360
%362 = sext i32 %361 to i64
%363 = sub i64 0, %362
%364 = getelementptr inbounds i8, i8* %359, i64 %363
%365 = bitcast i8* %364 to double*
%366 = getelementptr inbounds double, double* %365, i64 -1
store double* %366, double** %55
%367 = load double*, double** %5
%368 = bitcast double* %367 to i8*
%369 = load i32, i32* %17
%370 = mul nsw i32 8, %369
%371 = sext i32 %370 to i64
%372 = sub i64 0, %371
%373 = getelementptr inbounds i8, i8* %368, i64 %372
%374 = bitcast i8* %373 to double*
store double* %374, double** %56
%375 = load double*, double** %5
%376 = bitcast double* %375 to i8*
%377 = load i32, i32* %17
%378 = mul nsw i32 8, %377
%379 = sext i32 %378 to i64
%380 = sub i64 0, %379
%381 = getelementptr inbounds i8, i8* %376, i64 %380
%382 = bitcast i8* %381 to double*
%383 = getelementptr inbounds double, double* %382, i64 1
store double* %383, double** %57
%384 = load double*, double** %5
%385 = getelementptr inbounds double, double* %384, i64 -1
store double* %385, double** %58
%386 = load double*, double** %5
store double* %386, double** %59
%387 = load double*, double** %5
%388 = getelementptr inbounds double, double* %387, i64 1
store double* %388, double** %60
%389 = load double*, double** %5
%390 = bitcast double* %389 to i8*
%391 = load i32, i32* %17
%392 = mul nsw i32 8, %391
%393 = sext i32 %392 to i64
%394 = getelementptr inbounds i8, i8* %390, i64 %393
%395 = bitcast i8* %394 to double*
%396 = getelementptr inbounds double, double* %395, i64 -1
store double* %396, double** %61
%397 = load double*, double** %5
%398 = bitcast double* %397 to i8*
%399 = load i32, i32* %17
%400 = mul nsw i32 8, %399
%401 = sext i32 %400 to i64
%402 = getelementptr inbounds i8, i8* %398, i64 %401
%403 = bitcast i8* %402 to double*
store double* %403, double** %62
%404 = load double*, double** %5
%405 = bitcast double* %404 to i8*
%406 = load i32, i32* %17
%407 = mul nsw i32 8, %406
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds i8, i8* %405, i64 %408
%410 = bitcast i8* %409 to double*
%411 = getelementptr inbounds double, double* %410, i64 1
store double* %411, double** %63
%412 = load double*, double** %5
%413 = bitcast double* %412 to i8*
%414 = load i32, i32* %18
%415 = mul nsw i32 8, %414
%416 = sext i32 %415 to i64
%417 = getelementptr inbounds i8, i8* %413, i64 %416
%418 = load i32, i32* %17
%419 = mul nsw i32 8, %418
%420 = sext i32 %419 to i64
%421 = sub i64 0, %420
%422 = getelementptr inbounds i8, i8* %417, i64 %421
%423 = bitcast i8* %422 to double*
%424 = getelementptr inbounds double, double* %423, i64 -1
store double* %424, double** %64
%425 = load double*, double** %5
%426 = bitcast double* %425 to i8*
%427 = load i32, i32* %18
%428 = mul nsw i32 8, %427
%429 = sext i32 %428 to i64
%430 = getelementptr inbounds i8, i8* %426, i64 %429
%431 = load i32, i32* %17
%432 = mul nsw i32 8, %431
%433 = sext i32 %432 to i64
%434 = sub i64 0, %433
%435 = getelementptr inbounds i8, i8* %430, i64 %434
%436 = bitcast i8* %435 to double*
store double* %436, double** %65
%437 = load double*, double** %5
%438 = bitcast double* %437 to i8*
%439 = load i32, i32* %18
%440 = mul nsw i32 8, %439
%441 = sext i32 %440 to i64
%442 = getelementptr inbounds i8, i8* %438, i64 %441
%443 = load i32, i32* %17
%444 = mul nsw i32 8, %443
%445 = sext i32 %444 to i64
%446 = sub i64 0, %445
%447 = getelementptr inbounds i8, i8* %442, i64 %446
%448 = bitcast i8* %447 to double*
%449 = getelementptr inbounds double, double* %448, i64 1
store double* %449, double** %66
%450 = load double*, double** %5
%451 = bitcast double* %450 to i8*
%452 = load i32, i32* %18
%453 = mul nsw i32 8, %452
%454 = sext i32 %453 to i64
%455 = getelementptr inbounds i8, i8* %451, i64 %454
%456 = bitcast i8* %455 to double*
%457 = getelementptr inbounds double, double* %456, i64 -1
store double* %457, double** %67
%458 = load double*, double** %5
%459 = bitcast double* %458 to i8*
%460 = load i32, i32* %18
%461 = mul nsw i32 8, %460
%462 = sext i32 %461 to i64
%463 = getelementptr inbounds i8, i8* %459, i64 %462
%464 = bitcast i8* %463 to double*
store double* %464, double** %68
%465 = load double*, double** %5
%466 = bitcast double* %465 to i8*
%467 = load i32, i32* %18
%468 = mul nsw i32 8, %467
%469 = sext i32 %468 to i64
%470 = getelementptr inbounds i8, i8* %466, i64 %469
%471 = bitcast i8* %470 to double*
%472 = getelementptr inbounds double, double* %471, i64 1
store double* %472, double** %69
%473 = load double*, double** %5
%474 = bitcast double* %473 to i8*
%475 = load i32, i32* %18
%476 = mul nsw i32 8, %475
%477 = sext i32 %476 to i64
%478 = getelementptr inbounds i8, i8* %474, i64 %477
%479 = load i32, i32* %17
%480 = mul nsw i32 8, %479
%481 = sext i32 %480 to i64
%482 = getelementptr inbounds i8, i8* %478, i64 %481
%483 = bitcast i8* %482 to double*
%484 = getelementptr inbounds double, double* %483, i64 -1
store double* %484, double** %70
%485 = load double*, double** %5
%486 = bitcast double* %485 to i8*
%487 = load i32, i32* %18
%488 = mul nsw i32 8, %487
%489 = sext i32 %488 to i64
%490 = getelementptr inbounds i8, i8* %486, i64 %489
%491 = load i32, i32* %17
%492 = mul nsw i32 8, %491
%493 = sext i32 %492 to i64
%494 = getelementptr inbounds i8, i8* %490, i64 %493
%495 = bitcast i8* %494 to double*
store double* %495, double** %71
%496 = load double*, double** %5
%497 = bitcast double* %496 to i8*
%498 = load i32, i32* %18
%499 = mul nsw i32 8, %498
%500 = sext i32 %499 to i64
%501 = getelementptr inbounds i8, i8* %497, i64 %500
%502 = load i32, i32* %17
%503 = mul nsw i32 8, %502
%504 = sext i32 %503 to i64
%505 = getelementptr inbounds i8, i8* %501, i64 %504
%506 = bitcast i8* %505 to double*
%507 = getelementptr inbounds double, double* %506, i64 1
store double* %507, double** %72
store i32 2, i32* %73
br label %508
508: ; preds = %910, %3
%509 = load i32, i32* %73
%510 = load i32, i32* %12
%511 = sub nsw i32 %510, 1
%512 = icmp sle i32 %509, %511
br i1 %512, label %513, label %913
513: ; preds = %508
store i32 2, i32* %74
br label %514
514: ; preds = %906, %513
%515 = load i32, i32* %74
%516 = load i32, i32* %16
%517 = sub nsw i32 %516, 1
%518 = icmp sle i32 %515, %517
br i1 %518, label %519, label %909
519: ; preds = %514
store i32 2, i32* %75
br label %520
520: ; preds = %902, %519
%521 = load i32, i32* %75
%522 = load i32, i32* %14
%523 = sub nsw i32 %522, 1
%524 = icmp sle i32 %521, %523
br i1 %524, label %525, label %905
525: ; preds = %520
%526 = load i32, i32* %74
store i32 %526, i32* %76
br label %527
527: ; preds = %898, %525
%528 = load i32, i32* %76
%529 = load i32, i32* %16
%530 = sub nsw i32 %529, 1
%531 = load i32, i32* %74
%532 = add nsw i32 %531, 70
%533 = icmp slt i32 %530, %532
br i1 %533, label %534, label %537
534: ; preds = %527
%535 = load i32, i32* %16
%536 = sub nsw i32 %535, 1
br label %540
537: ; preds = %527
%538 = load i32, i32* %74
%539 = add nsw i32 %538, 70
br label %540
540: ; preds = %537, %534
%541 = phi i32 [ %536, %534 ], [ %539, %537 ]
%542 = icmp sle i32 %528, %541
br i1 %542, label %543, label %901
543: ; preds = %540
%544 = load i32, i32* %75
store i32 %544, i32* %77
br label %545
545: ; preds = %894, %543
%546 = load i32, i32* %77
%547 = load i32, i32* %14
%548 = sub nsw i32 %547, 1
%549 = load i32, i32* %75
%550 = add nsw i32 %549, 14
%551 = icmp slt i32 %548, %550
br i1 %551, label %552, label %555
552: ; preds = %545
%553 = load i32, i32* %14
%554 = sub nsw i32 %553, 1
br label %558
555: ; preds = %545
%556 = load i32, i32* %75
%557 = add nsw i32 %556, 14
br label %558
558: ; preds = %555, %552
%559 = phi i32 [ %554, %552 ], [ %557, %555 ]
%560 = icmp sle i32 %546, %559
br i1 %560, label %561, label %897
561: ; preds = %558
%562 = load i32, i32* %73
store i32 %562, i32* %78
br label %563
563: ; preds = %890, %561
%564 = load i32, i32* %78
%565 = load i32, i32* %12
%566 = sub nsw i32 %565, 1
%567 = load i32, i32* %73
%568 = add nsw i32 %567, 53
%569 = icmp slt i32 %566, %568
br i1 %569, label %570, label %573
570: ; preds = %563
%571 = load i32, i32* %12
%572 = sub nsw i32 %571, 1
br label %576
573: ; preds = %563
%574 = load i32, i32* %73
%575 = add nsw i32 %574, 53
br label %576
576: ; preds = %573, %570
%577 = phi i32 [ %572, %570 ], [ %575, %573 ]
%578 = icmp sle i32 %564, %577
br i1 %578, label %579, label %893
579: ; preds = %576
%580 = load i32, i32* %78
%581 = load i32, i32* %77
%582 = load i32, i32* %17
%583 = mul nsw i32 %581, %582
%584 = add nsw i32 %580, %583
%585 = load i32, i32* %76
%586 = load i32, i32* %18
%587 = mul nsw i32 %585, %586
%588 = add nsw i32 %584, %587
store i32 %588, i32* %7
%589 = load double*, double** %19
%590 = load i32, i32* %7
%591 = sext i32 %590 to i64
%592 = getelementptr inbounds double, double* %589, i64 %591
%593 = load double, double* %592
%594 = load double*, double** %46
%595 = load i32, i32* %7
%596 = sext i32 %595 to i64
%597 = getelementptr inbounds double, double* %594, i64 %596
%598 = load double, double* %597
%599 = load double*, double** %20
%600 = load i32, i32* %7
%601 = sext i32 %600 to i64
%602 = getelementptr inbounds double, double* %599, i64 %601
%603 = load double, double* %602
%604 = load double*, double** %47
%605 = load i32, i32* %7
%606 = sext i32 %605 to i64
%607 = getelementptr inbounds double, double* %604, i64 %606
%608 = load double, double* %607
%609 = fmul double %603, %608
%610 = call double @llvm.fmuladd.f64(double %593, double %598, double %609)
%611 = load double*, double** %21
%612 = load i32, i32* %7
%613 = sext i32 %612 to i64
%614 = getelementptr inbounds double, double* %611, i64 %613
%615 = load double, double* %614
%616 = load double*, double** %48
%617 = load i32, i32* %7
%618 = sext i32 %617 to i64
%619 = getelementptr inbounds double, double* %616, i64 %618
%620 = load double, double* %619
%621 = call double @llvm.fmuladd.f64(double %615, double %620, double %610)
%622 = load double*, double** %22
%623 = load i32, i32* %7
%624 = sext i32 %623 to i64
%625 = getelementptr inbounds double, double* %622, i64 %624
%626 = load double, double* %625
%627 = load double*, double** %49
%628 = load i32, i32* %7
%629 = sext i32 %628 to i64
%630 = getelementptr inbounds double, double* %627, i64 %629
%631 = load double, double* %630
%632 = call double @llvm.fmuladd.f64(double %626, double %631, double %621)
%633 = load double*, double** %23
%634 = load i32, i32* %7
%635 = sext i32 %634 to i64
%636 = getelementptr inbounds double, double* %633, i64 %635
%637 = load double, double* %636
%638 = load double*, double** %50
%639 = load i32, i32* %7
%640 = sext i32 %639 to i64
%641 = getelementptr inbounds double, double* %638, i64 %640
%642 = load double, double* %641
%643 = call double @llvm.fmuladd.f64(double %637, double %642, double %632)
%644 = load double*, double** %24
%645 = load i32, i32* %7
%646 = sext i32 %645 to i64
%647 = getelementptr inbounds double, double* %644, i64 %646
%648 = load double, double* %647
%649 = load double*, double** %51
%650 = load i32, i32* %7
%651 = sext i32 %650 to i64
%652 = getelementptr inbounds double, double* %649, i64 %651
%653 = load double, double* %652
%654 = call double @llvm.fmuladd.f64(double %648, double %653, double %643)
%655 = load double*, double** %25
%656 = load i32, i32* %7
%657 = sext i32 %656 to i64
%658 = getelementptr inbounds double, double* %655, i64 %657
%659 = load double, double* %658
%660 = load double*, double** %52
%661 = load i32, i32* %7
%662 = sext i32 %661 to i64
%663 = getelementptr inbounds double, double* %660, i64 %662
%664 = load double, double* %663
%665 = call double @llvm.fmuladd.f64(double %659, double %664, double %654)
%666 = load double*, double** %26
%667 = load i32, i32* %7
%668 = sext i32 %667 to i64
%669 = getelementptr inbounds double, double* %666, i64 %668
%670 = load double, double* %669
%671 = load double*, double** %53
%672 = load i32, i32* %7
%673 = sext i32 %672 to i64
%674 = getelementptr inbounds double, double* %671, i64 %673
%675 = load double, double* %674
%676 = call double @llvm.fmuladd.f64(double %670, double %675, double %665)
%677 = load double*, double** %27
%678 = load i32, i32* %7
%679 = sext i32 %678 to i64
%680 = getelementptr inbounds double, double* %677, i64 %679
%681 = load double, double* %680
%682 = load double*, double** %54
%683 = load i32, i32* %7
%684 = sext i32 %683 to i64
%685 = getelementptr inbounds double, double* %682, i64 %684
%686 = load double, double* %685
%687 = call double @llvm.fmuladd.f64(double %681, double %686, double %676)
%688 = load double*, double** %28
%689 = load i32, i32* %7
%690 = sext i32 %689 to i64
%691 = getelementptr inbounds double, double* %688, i64 %690
%692 = load double, double* %691
%693 = load double*, double** %55
%694 = load i32, i32* %7
%695 = sext i32 %694 to i64
%696 = getelementptr inbounds double, double* %693, i64 %695
%697 = load double, double* %696
%698 = call double @llvm.fmuladd.f64(double %692, double %697, double %687)
%699 = load double*, double** %29
%700 = load i32, i32* %7
%701 = sext i32 %700 to i64
%702 = getelementptr inbounds double, double* %699, i64 %701
%703 = load double, double* %702
%704 = load double*, double** %56
%705 = load i32, i32* %7
%706 = sext i32 %705 to i64
%707 = getelementptr inbounds double, double* %704, i64 %706
%708 = load double, double* %707
%709 = call double @llvm.fmuladd.f64(double %703, double %708, double %698)
%710 = load double*, double** %30
%711 = load i32, i32* %7
%712 = sext i32 %711 to i64
%713 = getelementptr inbounds double, double* %710, i64 %712
%714 = load double, double* %713
%715 = load double*, double** %57
%716 = load i32, i32* %7
%717 = sext i32 %716 to i64
%718 = getelementptr inbounds double, double* %715, i64 %717
%719 = load double, double* %718
%720 = call double @llvm.fmuladd.f64(double %714, double %719, double %709)
%721 = load double*, double** %31
%722 = load i32, i32* %7
%723 = sext i32 %722 to i64
%724 = getelementptr inbounds double, double* %721, i64 %723
%725 = load double, double* %724
%726 = load double*, double** %58
%727 = load i32, i32* %7
%728 = sext i32 %727 to i64
%729 = getelementptr inbounds double, double* %726, i64 %728
%730 = load double, double* %729
%731 = call double @llvm.fmuladd.f64(double %725, double %730, double %720)
%732 = load double*, double** %32
%733 = load i32, i32* %7
%734 = sext i32 %733 to i64
%735 = getelementptr inbounds double, double* %732, i64 %734
%736 = load double, double* %735
%737 = load double*, double** %59
%738 = load i32, i32* %7
%739 = sext i32 %738 to i64
%740 = getelementptr inbounds double, double* %737, i64 %739
%741 = load double, double* %740
%742 = call double @llvm.fmuladd.f64(double %736, double %741, double %731)
%743 = load double*, double** %33
%744 = load i32, i32* %7
%745 = sext i32 %744 to i64
%746 = getelementptr inbounds double, double* %743, i64 %745
%747 = load double, double* %746
%748 = load double*, double** %60
%749 = load i32, i32* %7
%750 = sext i32 %749 to i64
%751 = getelementptr inbounds double, double* %748, i64 %750
%752 = load double, double* %751
%753 = call double @llvm.fmuladd.f64(double %747, double %752, double %742)
%754 = load double*, double** %34
%755 = load i32, i32* %7
%756 = sext i32 %755 to i64
%757 = getelementptr inbounds double, double* %754, i64 %756
%758 = load double, double* %757
%759 = load double*, double** %61
%760 = load i32, i32* %7
%761 = sext i32 %760 to i64
%762 = getelementptr inbounds double, double* %759, i64 %761
%763 = load double, double* %762
%764 = call double @llvm.fmuladd.f64(double %758, double %763, double %753)
%765 = load double*, double** %35
%766 = load i32, i32* %7
%767 = sext i32 %766 to i64
%768 = getelementptr inbounds double, double* %765, i64 %767
%769 = load double, double* %768
%770 = load double*, double** %62
%771 = load i32, i32* %7
%772 = sext i32 %771 to i64
%773 = getelementptr inbounds double, double* %770, i64 %772
%774 = load double, double* %773
%775 = call double @llvm.fmuladd.f64(double %769, double %774, double %764)
%776 = load double*, double** %36
%777 = load i32, i32* %7
%778 = sext i32 %777 to i64
%779 = getelementptr inbounds double, double* %776, i64 %778
%780 = load double, double* %779
%781 = load double*, double** %63
%782 = load i32, i32* %7
%783 = sext i32 %782 to i64
%784 = getelementptr inbounds double, double* %781, i64 %783
%785 = load double, double* %784
%786 = call double @llvm.fmuladd.f64(double %780, double %785, double %775)
%787 = load double*, double** %37
%788 = load i32, i32* %7
%789 = sext i32 %788 to i64
%790 = getelementptr inbounds double, double* %787, i64 %789
%791 = load double, double* %790
%792 = load double*, double** %64
%793 = load i32, i32* %7
%794 = sext i32 %793 to i64
%795 = getelementptr inbounds double, double* %792, i64 %794
%796 = load double, double* %795
%797 = call double @llvm.fmuladd.f64(double %791, double %796, double %786)
%798 = load double*, double** %38
%799 = load i32, i32* %7
%800 = sext i32 %799 to i64
%801 = getelementptr inbounds double, double* %798, i64 %800
%802 = load double, double* %801
%803 = load double*, double** %65
%804 = load i32, i32* %7
%805 = sext i32 %804 to i64
%806 = getelementptr inbounds double, double* %803, i64 %805
%807 = load double, double* %806
%808 = call double @llvm.fmuladd.f64(double %802, double %807, double %797)
%809 = load double*, double** %39
%810 = load i32, i32* %7
%811 = sext i32 %810 to i64
%812 = getelementptr inbounds double, double* %809, i64 %811
%813 = load double, double* %812
%814 = load double*, double** %66
%815 = load i32, i32* %7
%816 = sext i32 %815 to i64
%817 = getelementptr inbounds double, double* %814, i64 %816
%818 = load double, double* %817
%819 = call double @llvm.fmuladd.f64(double %813, double %818, double %808)
%820 = load double*, double** %40
%821 = load i32, i32* %7
%822 = sext i32 %821 to i64
%823 = getelementptr inbounds double, double* %820, i64 %822
%824 = load double, double* %823
%825 = load double*, double** %67
%826 = load i32, i32* %7
%827 = sext i32 %826 to i64
%828 = getelementptr inbounds double, double* %825, i64 %827
%829 = load double, double* %828
%830 = call double @llvm.fmuladd.f64(double %824, double %829, double %819)
%831 = load double*, double** %41
%832 = load i32, i32* %7
%833 = sext i32 %832 to i64
%834 = getelementptr inbounds double, double* %831, i64 %833
%835 = load double, double* %834
%836 = load double*, double** %68
%837 = load i32, i32* %7
%838 = sext i32 %837 to i64
%839 = getelementptr inbounds double, double* %836, i64 %838
%840 = load double, double* %839
%841 = call double @llvm.fmuladd.f64(double %835, double %840, double %830)
%842 = load double*, double** %42
%843 = load i32, i32* %7
%844 = sext i32 %843 to i64
%845 = getelementptr inbounds double, double* %842, i64 %844
%846 = load double, double* %845
%847 = load double*, double** %69
%848 = load i32, i32* %7
%849 = sext i32 %848 to i64
%850 = getelementptr inbounds double, double* %847, i64 %849
%851 = load double, double* %850
%852 = call double @llvm.fmuladd.f64(double %846, double %851, double %841)
%853 = load double*, double** %43
%854 = load i32, i32* %7
%855 = sext i32 %854 to i64
%856 = getelementptr inbounds double, double* %853, i64 %855
%857 = load double, double* %856
%858 = load double*, double** %70
%859 = load i32, i32* %7
%860 = sext i32 %859 to i64
%861 = getelementptr inbounds double, double* %858, i64 %860
%862 = load double, double* %861
%863 = call double @llvm.fmuladd.f64(double %857, double %862, double %852)
%864 = load double*, double** %44
%865 = load i32, i32* %7
%866 = sext i32 %865 to i64
%867 = getelementptr inbounds double, double* %864, i64 %866
%868 = load double, double* %867
%869 = load double*, double** %71
%870 = load i32, i32* %7
%871 = sext i32 %870 to i64
%872 = getelementptr inbounds double, double* %869, i64 %871
%873 = load double, double* %872
%874 = call double @llvm.fmuladd.f64(double %868, double %873, double %863)
%875 = load double*, double** %45
%876 = load i32, i32* %7
%877 = sext i32 %876 to i64
%878 = getelementptr inbounds double, double* %875, i64 %877
%879 = load double, double* %878
%880 = load double*, double** %72
%881 = load i32, i32* %7
%882 = sext i32 %881 to i64
%883 = getelementptr inbounds double, double* %880, i64 %882
%884 = load double, double* %883
%885 = call double @llvm.fmuladd.f64(double %879, double %884, double %874)
%886 = load double*, double** %6
%887 = load i32, i32* %7
%888 = sext i32 %887 to i64
%889 = getelementptr inbounds double, double* %886, i64 %888
store double %885, double* %889
br label %890
890: ; preds = %579
%891 = load i32, i32* %78
%892 = add nsw i32 %891, 1
store i32 %892, i32* %78
br label %563
893: ; preds = %576
br label %894
894: ; preds = %893
%895 = load i32, i32* %77
%896 = add nsw i32 %895, 1
store i32 %896, i32* %77
br label %545
897: ; preds = %558
br label %898
898: ; preds = %897
%899 = load i32, i32* %76
%900 = add nsw i32 %899, 1
store i32 %900, i32* %76
br label %527
901: ; preds = %540
br label %902
902: ; preds = %901
%903 = load i32, i32* %75
%904 = add nsw i32 %903, 15
store i32 %904, i32* %75
br label %520
905: ; preds = %520
br label %906
906: ; preds = %905
%907 = load i32, i32* %74
%908 = add nsw i32 %907, 71
store i32 %908, i32* %74
br label %514
909: ; preds = %514
br label %910
910: ; preds = %909
%911 = load i32, i32* %73
%912 = add nsw i32 %911, 54
store i32 %912, i32* %73
br label %508
913: ; preds = %508
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 = bitcast double* %1 to i8*
%133 = shl nsw i32 %23, 3
%134 = sext i32 %133 to i64
%135 = sub nsw i64 0, %134
%136 = getelementptr inbounds i8, i8* %132, i64 %135
%137 = shl nsw i32 %19, 3
%138 = sext i32 %137 to i64
%139 = sub nsw i64 0, %138
%140 = getelementptr inbounds i8, i8* %136, i64 %139
%141 = bitcast i8* %140 to double*
%142 = getelementptr inbounds i8, i8* %140, i64 -8
%143 = bitcast i8* %142 to double*
%144 = getelementptr inbounds i8, i8* %140, i64 8
%145 = bitcast i8* %144 to double*
%146 = bitcast i8* %136 to double*
%147 = getelementptr inbounds i8, i8* %136, i64 -8
%148 = bitcast i8* %147 to double*
%149 = getelementptr inbounds i8, i8* %136, i64 8
%150 = bitcast i8* %149 to double*
%151 = getelementptr inbounds i8, i8* %136, i64 %138
%152 = bitcast i8* %151 to double*
%153 = getelementptr inbounds i8, i8* %151, i64 -8
%154 = bitcast i8* %153 to double*
%155 = getelementptr inbounds i8, i8* %151, i64 8
%156 = bitcast i8* %155 to double*
%157 = getelementptr inbounds i8, i8* %132, i64 %139
%158 = bitcast i8* %157 to double*
%159 = getelementptr inbounds i8, i8* %157, i64 -8
%160 = bitcast i8* %159 to double*
%161 = getelementptr inbounds i8, i8* %157, i64 8
%162 = bitcast i8* %161 to double*
%163 = getelementptr inbounds double, double* %1, i64 -1
%164 = getelementptr inbounds double, double* %1, i64 1
%165 = getelementptr inbounds i8, i8* %132, i64 %138
%166 = bitcast i8* %165 to double*
%167 = getelementptr inbounds i8, i8* %165, i64 -8
%168 = bitcast i8* %167 to double*
%169 = getelementptr inbounds i8, i8* %165, i64 8
%170 = bitcast i8* %169 to double*
%171 = getelementptr inbounds i8, i8* %132, i64 %134
%172 = getelementptr inbounds i8, i8* %171, i64 %139
%173 = bitcast i8* %172 to double*
%174 = getelementptr inbounds i8, i8* %172, i64 -8
%175 = bitcast i8* %174 to double*
%176 = getelementptr inbounds i8, i8* %172, i64 8
%177 = bitcast i8* %176 to double*
%178 = bitcast i8* %171 to double*
%179 = getelementptr inbounds i8, i8* %171, i64 -8
%180 = bitcast i8* %179 to double*
%181 = getelementptr inbounds i8, i8* %171, i64 8
%182 = bitcast i8* %181 to double*
%183 = getelementptr inbounds i8, i8* %171, i64 %138
%184 = bitcast i8* %183 to double*
%185 = getelementptr inbounds i8, i8* %183, i64 -8
%186 = bitcast i8* %185 to double*
%187 = getelementptr inbounds i8, i8* %183, i64 8
%188 = bitcast i8* %187 to double*
%189 = add nsw i32 %7, -1
%190 = icmp sgt i32 %7, 2
br i1 %190, label %191, label %387
191: ; preds = %3
%192 = add nsw i32 %15, -1
%193 = icmp sgt i32 %15, 2
%194 = add nsw i32 %11, -1
%195 = icmp sgt i32 %11, 2
br label %196
196: ; preds = %191, %383
%197 = phi i64 [ 2, %191 ], [ %384, %383 ]
%198 = trunc i64 %197 to i32
br i1 %193, label %199, label %383
199: ; preds = %196
%200 = add nuw nsw i32 %198, 53
%201 = icmp slt i32 %189, %200
%202 = select i1 %201, i32 %189, i32 %200
%203 = icmp slt i32 %202, %198
%204 = sext i32 %202 to i64
br label %205
205: ; preds = %199, %380
%206 = phi i32 [ 2, %199 ], [ %381, %380 ]
br i1 %195, label %207, label %380
207: ; preds = %205
%208 = add nuw nsw i32 %206, 70
%209 = icmp slt i32 %192, %208
%210 = select i1 %209, i32 %192, i32 %208
%211 = icmp sgt i32 %206, %210
br label %212
212: ; preds = %207, %377
%213 = phi i32 [ 2, %207 ], [ %378, %377 ]
br i1 %211, label %377, label %214
214: ; preds = %212
%215 = add nuw nsw i32 %213, 14
%216 = icmp slt i32 %194, %215
%217 = select i1 %216, i32 %194, i32 %215
%218 = icmp sgt i32 %213, %217
br label %219
219: ; preds = %214, %374
%220 = phi i32 [ %206, %214 ], [ %375, %374 ]
br i1 %218, label %374, label %221
221: ; preds = %219
%222 = mul nsw i32 %220, %23
br label %223
223: ; preds = %221, %371
%224 = phi i32 [ %213, %221 ], [ %372, %371 ]
br i1 %203, label %371, label %225
225: ; preds = %223
%226 = mul nsw i32 %224, %19
%227 = add i32 %226, %222
br label %228
228: ; preds = %225, %228
%229 = phi i64 [ %197, %225 ], [ %369, %228 ]
%230 = trunc i64 %229 to i32
%231 = add i32 %227, %230
%232 = sext i32 %231 to i64
%233 = getelementptr inbounds double, double* %27, i64 %232
%234 = load double, double* %233
%235 = getelementptr inbounds double, double* %143, i64 %232
%236 = load double, double* %235
%237 = getelementptr inbounds double, double* %31, i64 %232
%238 = load double, double* %237
%239 = getelementptr inbounds double, double* %141, i64 %232
%240 = load double, double* %239
%241 = fmul double %238, %240
%242 = tail call double @llvm.fmuladd.f64(double %234, double %236, double %241)
%243 = getelementptr inbounds double, double* %35, i64 %232
%244 = load double, double* %243
%245 = getelementptr inbounds double, double* %145, i64 %232
%246 = load double, double* %245
%247 = tail call double @llvm.fmuladd.f64(double %244, double %246, double %242)
%248 = getelementptr inbounds double, double* %39, i64 %232
%249 = load double, double* %248
%250 = getelementptr inbounds double, double* %148, i64 %232
%251 = load double, double* %250
%252 = tail call double @llvm.fmuladd.f64(double %249, double %251, double %247)
%253 = getelementptr inbounds double, double* %43, i64 %232
%254 = load double, double* %253
%255 = getelementptr inbounds double, double* %146, i64 %232
%256 = load double, double* %255
%257 = tail call double @llvm.fmuladd.f64(double %254, double %256, double %252)
%258 = getelementptr inbounds double, double* %47, i64 %232
%259 = load double, double* %258
%260 = getelementptr inbounds double, double* %150, i64 %232
%261 = load double, double* %260
%262 = tail call double @llvm.fmuladd.f64(double %259, double %261, double %257)
%263 = getelementptr inbounds double, double* %51, i64 %232
%264 = load double, double* %263
%265 = getelementptr inbounds double, double* %154, i64 %232
%266 = load double, double* %265
%267 = tail call double @llvm.fmuladd.f64(double %264, double %266, double %262)
%268 = getelementptr inbounds double, double* %55, i64 %232
%269 = load double, double* %268
%270 = getelementptr inbounds double, double* %152, i64 %232
%271 = load double, double* %270
%272 = tail call double @llvm.fmuladd.f64(double %269, double %271, double %267)
%273 = getelementptr inbounds double, double* %59, i64 %232
%274 = load double, double* %273
%275 = getelementptr inbounds double, double* %156, i64 %232
%276 = load double, double* %275
%277 = tail call double @llvm.fmuladd.f64(double %274, double %276, double %272)
%278 = getelementptr inbounds double, double* %63, i64 %232
%279 = load double, double* %278
%280 = getelementptr inbounds double, double* %160, i64 %232
%281 = load double, double* %280
%282 = tail call double @llvm.fmuladd.f64(double %279, double %281, double %277)
%283 = getelementptr inbounds double, double* %67, i64 %232
%284 = load double, double* %283
%285 = getelementptr inbounds double, double* %158, i64 %232
%286 = load double, double* %285
%287 = tail call double @llvm.fmuladd.f64(double %284, double %286, double %282)
%288 = getelementptr inbounds double, double* %71, i64 %232
%289 = load double, double* %288
%290 = getelementptr inbounds double, double* %162, i64 %232
%291 = load double, double* %290
%292 = tail call double @llvm.fmuladd.f64(double %289, double %291, double %287)
%293 = getelementptr inbounds double, double* %75, i64 %232
%294 = load double, double* %293
%295 = getelementptr inbounds double, double* %163, i64 %232
%296 = load double, double* %295
%297 = tail call double @llvm.fmuladd.f64(double %294, double %296, double %292)
%298 = getelementptr inbounds double, double* %79, i64 %232
%299 = load double, double* %298
%300 = getelementptr inbounds double, double* %1, i64 %232
%301 = load double, double* %300
%302 = tail call double @llvm.fmuladd.f64(double %299, double %301, double %297)
%303 = getelementptr inbounds double, double* %83, i64 %232
%304 = load double, double* %303
%305 = getelementptr inbounds double, double* %164, i64 %232
%306 = load double, double* %305
%307 = tail call double @llvm.fmuladd.f64(double %304, double %306, double %302)
%308 = getelementptr inbounds double, double* %87, i64 %232
%309 = load double, double* %308
%310 = getelementptr inbounds double, double* %168, i64 %232
%311 = load double, double* %310
%312 = tail call double @llvm.fmuladd.f64(double %309, double %311, double %307)
%313 = getelementptr inbounds double, double* %91, i64 %232
%314 = load double, double* %313
%315 = getelementptr inbounds double, double* %166, i64 %232
%316 = load double, double* %315
%317 = tail call double @llvm.fmuladd.f64(double %314, double %316, double %312)
%318 = getelementptr inbounds double, double* %95, i64 %232
%319 = load double, double* %318
%320 = getelementptr inbounds double, double* %170, i64 %232
%321 = load double, double* %320
%322 = tail call double @llvm.fmuladd.f64(double %319, double %321, double %317)
%323 = getelementptr inbounds double, double* %99, i64 %232
%324 = load double, double* %323
%325 = getelementptr inbounds double, double* %175, i64 %232
%326 = load double, double* %325
%327 = tail call double @llvm.fmuladd.f64(double %324, double %326, double %322)
%328 = getelementptr inbounds double, double* %103, i64 %232
%329 = load double, double* %328
%330 = getelementptr inbounds double, double* %173, i64 %232
%331 = load double, double* %330
%332 = tail call double @llvm.fmuladd.f64(double %329, double %331, double %327)
%333 = getelementptr inbounds double, double* %107, i64 %232
%334 = load double, double* %333
%335 = getelementptr inbounds double, double* %177, i64 %232
%336 = load double, double* %335
%337 = tail call double @llvm.fmuladd.f64(double %334, double %336, double %332)
%338 = getelementptr inbounds double, double* %111, i64 %232
%339 = load double, double* %338
%340 = getelementptr inbounds double, double* %180, i64 %232
%341 = load double, double* %340
%342 = tail call double @llvm.fmuladd.f64(double %339, double %341, double %337)
%343 = getelementptr inbounds double, double* %115, i64 %232
%344 = load double, double* %343
%345 = getelementptr inbounds double, double* %178, i64 %232
%346 = load double, double* %345
%347 = tail call double @llvm.fmuladd.f64(double %344, double %346, double %342)
%348 = getelementptr inbounds double, double* %119, i64 %232
%349 = load double, double* %348
%350 = getelementptr inbounds double, double* %182, i64 %232
%351 = load double, double* %350
%352 = tail call double @llvm.fmuladd.f64(double %349, double %351, double %347)
%353 = getelementptr inbounds double, double* %123, i64 %232
%354 = load double, double* %353
%355 = getelementptr inbounds double, double* %186, i64 %232
%356 = load double, double* %355
%357 = tail call double @llvm.fmuladd.f64(double %354, double %356, double %352)
%358 = getelementptr inbounds double, double* %127, i64 %232
%359 = load double, double* %358
%360 = getelementptr inbounds double, double* %184, i64 %232
%361 = load double, double* %360
%362 = tail call double @llvm.fmuladd.f64(double %359, double %361, double %357)
%363 = getelementptr inbounds double, double* %131, i64 %232
%364 = load double, double* %363
%365 = getelementptr inbounds double, double* %188, i64 %232
%366 = load double, double* %365
%367 = tail call double @llvm.fmuladd.f64(double %364, double %366, double %362)
%368 = getelementptr inbounds double, double* %2, i64 %232
store double %367, double* %368
%369 = add nuw nsw i64 %229, 1
%370 = icmp slt i64 %229, %204
br i1 %370, label %228, label %371
371: ; preds = %228, %223
%372 = add nuw nsw i32 %224, 1
%373 = icmp slt i32 %224, %217
br i1 %373, label %223, label %374
374: ; preds = %371, %219
%375 = add nuw nsw i32 %220, 1
%376 = icmp slt i32 %220, %210
br i1 %376, label %219, label %377
377: ; preds = %374, %212
%378 = add nuw nsw i32 %213, 15
%379 = icmp slt i32 %378, %11
br i1 %379, label %212, label %380
380: ; preds = %377, %205
%381 = add nuw nsw i32 %206, 71
%382 = icmp slt i32 %381, %15
br i1 %382, label %205, label %383
383: ; preds = %380, %196
%384 = add nuw nsw i64 %197, 54
%385 = trunc i64 %384 to i32
%386 = icmp sgt i32 %7, %385
br i1 %386, label %196, label %387
387: ; preds = %383, %3
ret void
}