diff --git a/frame/compat/bla_imatcopy.c b/frame/compat/bla_imatcopy.c
new file mode 100644
index 0000000000..5d8a8af101
--- /dev/null
+++ b/frame/compat/bla_imatcopy.c
@@ -0,0 +1,608 @@
+/*
+
+   BLIS
+   An object-based framework for developing high-performance BLAS-like
+   libraries.
+
+   Copyright (C) 2020, Advanced Micro Devices, Inc. All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+    - Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    - Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    - Neither the name(s) of the copyright holder(s) nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "blis.h"
+
+#ifdef BLIS_ENABLE_BLAS
+
+static dim_t bli_siMatCopy_cn(dim_t rows,dim_t cols,const float alpha,float* a,dim_t lda, dim_t ldb);
+
+static dim_t bli_diMatCopy_cn(dim_t rows,dim_t cols,const double alpha,double* a,dim_t lda, dim_t ldb);
+
+static dim_t bli_ciMatCopy_cn(dim_t rows,dim_t cols,const scomplex alpha,scomplex* a,dim_t lda, dim_t ldb);
+
+static dim_t bli_ciMatCopy_cr(dim_t rows,dim_t cols,const scomplex alpha,scomplex* a,dim_t lda, dim_t ldb);
+
+static dim_t bli_ziMatCopy_cn(dim_t rows,dim_t cols,const dcomplex alpha,dcomplex* a,dim_t lda, dim_t ldb);
+
+static dim_t bli_ziMatCopy_cr(dim_t rows,dim_t cols,const dcomplex alpha,dcomplex* a,dim_t lda, dim_t ldb);
+
+static void bli_stranspose(float* A,float* B,dim_t cols, dim_t rows);
+
+static void bli_dtranspose(double* A,double* B,dim_t cols, dim_t rows);
+
+static void bli_ctranspose(scomplex* A,scomplex* B,dim_t cols, dim_t rows);
+
+static void bli_ztranspose(dcomplex* A,dcomplex* B,dim_t cols, dim_t rows);
+
+static void bli_stranspose(float* A,float* B,dim_t cols, dim_t rows)
+{
+ for (dim_t i = 0; i < cols; i++)
+  for (dim_t j = 0; j < rows; j++)
+   B[j*cols + i] = A[i*rows +j];
+}
+
+static void bli_dtranspose(double* A,double* B,dim_t cols, dim_t rows)
+{
+ for (dim_t i = 0; i < cols; i++)
+  for (dim_t j = 0; j < rows; j++)
+   B[j*cols + i] = A[i*rows +j];
+}
+
+static void bli_ctranspose(scomplex* A,scomplex* B,dim_t cols, dim_t rows)
+{
+ for (dim_t i = 0; i < cols; i++)
+  for (dim_t j = 0; j < rows; j++)
+   B[j*cols + i] = A[i*rows +j];
+}
+
+static void bli_ztranspose(dcomplex* A,dcomplex* B,dim_t cols, dim_t rows)
+{
+ for (dim_t i = 0; i < cols; i++)
+  for (dim_t j = 0; j < rows; j++)
+   B[j*cols + i] = A[i*rows +j];
+}
+
+void simatcopy_ (f77_char* trans, f77_int* rows, f77_int* cols, const float* alpha,float* aptr, f77_int* lda, f77_int* ldb)
+{
+ //bli_init_once();
+ if ( !(*trans == 'n' || *trans == 'N' ||
+  *trans == 't' || *trans == 'T' ||
+  *trans == 'c' || *trans == 'C' ||
+  *trans == 'r' || *trans == 'R'))
+ {
+  bli_print_msg( " Invalid trans  setting simatcopy_() .", __FILE__, __LINE__ );
+  return ;
+ }
+
+ if ( *rows <= 0 || *cols <= 0 || alpha == NULL || aptr == NULL || *lda < 1 || *ldb < 1)
+ {
+  bli_print_msg( " Invalid function parameters simatcopy_() .", __FILE__, __LINE__ );
+  return ;
+ }
+
+ if ( *trans == 'n' || *trans == 'N')
+ {
+  bli_siMatCopy_cn(*rows,*cols,*alpha,aptr,*lda,*ldb);
+ }
+ else if ( *trans == 't' || *trans == 'T')
+ {
+  //pre transpose
+  float* temp = (float* ) bli_malloc_user((*rows)*(*lda)*sizeof(float),NULL);
+  bli_stranspose(aptr,temp,*lda,*rows);
+  
+  for (dim_t i = 0; i < *cols; i++)
+   memcpy(&aptr[i*(*lda)],&temp[i*(*lda)],(*rows)*sizeof(float));
+ 
+  bli_siMatCopy_cn(*cols,*rows,*alpha,aptr,*lda,*ldb);
+
+  //post transpose
+  //bli_stranspose(temp,aptr,*lda,*cols);
+  bli_free_user(temp);
+ }
+ else if ( *trans == 'c' || *trans == 'C')
+ {
+  //pre transpose
+  float* temp = (float* ) bli_malloc_user((*rows)*(*lda)*sizeof(float),NULL);
+  bli_stranspose(aptr,temp,*lda,*rows);
+
+  for (dim_t i = 0; i < *cols; i++)
+   memcpy(&aptr[i*(*lda)],&temp[i*(*lda)],(*rows)*sizeof(float));
+
+  //bli_siMatCopy_cn(*cols,*rows,*alpha,temp,*lda,*ldb);
+  
+  bli_siMatCopy_cn(*cols,*rows,*alpha,aptr,*lda,*ldb);
+  //post transpose
+  //bli_stranspose(temp,aptr,*lda,*cols);
+  bli_free_user(temp);
+ }
+ else if ( *trans == 'r' || *trans == 'R')
+ {
+  bli_siMatCopy_cn(*rows,*cols,*alpha,aptr,*lda,*ldb);
+ }
+ else
+ {
+ // do nothing
+ }
+ return ;
+}
+
+void dimatcopy_ (f77_char* trans, f77_int* rows, f77_int* cols, const double* alpha,double* aptr, f77_int* lda, f77_int* ldb)
+{
+ //bli_init_once();
+ if ( !(*trans == 'n' || *trans == 'N' ||
+  *trans == 't' || *trans == 'T' ||
+  *trans == 'c' || *trans == 'C' ||
+  *trans == 'r' || *trans == 'R'))
+ {
+  bli_print_msg( " Invalid trans  setting dimatcopy_() .", __FILE__, __LINE__ );
+  return ;
+ }
+
+ if ( *rows <= 0 || *cols <= 0 || alpha == NULL || aptr == NULL || *lda < 1 || *ldb < 1)
+ {
+  bli_print_msg( " Invalid function parameters dimatcopy_() .", __FILE__, __LINE__ );
+  return ;
+ }
+
+ if ( *trans == 'n' || *trans == 'N')
+ {
+  bli_diMatCopy_cn(*rows,*cols,*alpha,aptr,*lda,*ldb);
+ }
+ else if ( *trans == 't' || *trans == 'T')
+ {
+  //pre transpose
+  double* temp = (double* ) bli_malloc_user((*rows)*(*lda)*sizeof(double),NULL);
+  bli_dtranspose(aptr,temp,*lda,*rows);
+     
+  for (dim_t i = 0; i < *cols; i++)
+   memcpy(&aptr[i*(*lda)],&temp[i*(*lda)],(*rows)*sizeof(double));
+
+  bli_diMatCopy_cn(*cols,*rows,*alpha,aptr,*lda,*ldb);
+  
+  //post transpose
+  //bli_dtranspose(temp,aptr,*rows,*lda);
+  //bli_dtranspose(temp,aptr,*lda,*cols);
+  bli_free_user(temp);
+ }
+ else if ( *trans == 'c' || *trans == 'C')
+ {
+  //pre transpose
+  double* temp = (double* ) bli_malloc_user((*rows)*(*lda)*sizeof(double),NULL);
+  bli_dtranspose(aptr,temp,*lda,*rows);
+
+  for (dim_t i = 0; i < *cols; i++)
+   memcpy(&aptr[i*(*lda)],&temp[i*(*lda)],(*rows)*sizeof(double));
+  
+  bli_diMatCopy_cn(*cols,*rows,*alpha,aptr,*lda,*ldb);
+    
+  //post transpose
+  //bli_dtranspose(temp,aptr,*lda,*cols);
+  bli_free_user(temp);
+ }
+ else if ( *trans == 'r' || *trans == 'R')
+ {
+  bli_diMatCopy_cn(*rows,*cols,*alpha,aptr,*lda,*ldb);
+ }
+ else
+ {
+ // do nothing
+ }
+ return ;
+}
+
+void cimatcopy_ (f77_char* trans, f77_int* rows, f77_int* cols, const scomplex* alpha,scomplex* aptr, f77_int* lda, f77_int* ldb)
+{
+ //bli_init_once();
+ if ( !(*trans == 'n' || *trans == 'N' ||
+  *trans == 't' || *trans == 'T' ||
+  *trans == 'c' || *trans == 'C' ||
+  *trans == 'r' || *trans == 'R'))
+ {
+  bli_print_msg( " Invalid trans  setting cimatcopy_() .", __FILE__, __LINE__ );
+  return ;
+ }
+
+ if ( *rows <= 0 || *cols <= 0 || alpha == NULL || aptr == NULL || *lda < 1 || *ldb < 1)
+ {
+  bli_print_msg( " Invalid function parameters cimatcopy_() .", __FILE__, __LINE__ );
+  return ;
+ }
+
+ if ( *trans == 'n' || *trans == 'N')
+ {
+  bli_ciMatCopy_cn(*rows,*cols,*alpha,aptr,*lda,*ldb);
+ }
+ else if ( *trans == 't' || *trans == 'T')
+ {
+  //pre transpose
+  scomplex* temp = (scomplex* ) bli_malloc_user((*rows)*(*lda)*sizeof(scomplex),NULL);
+  bli_ctranspose(aptr,temp,*lda,*rows);
+
+  //bli_ciMatCopy_cn(*cols,*rows,*alpha,temp,*lda,*ldb);
+  for (dim_t i = 0; i < *cols; i++)
+   memcpy(&aptr[i*(*lda)],&temp[i*(*lda)],(*rows)*sizeof(scomplex));
+  bli_ciMatCopy_cn(*cols,*rows,*alpha,aptr,*lda,*ldb);
+
+  //post transpose
+  //bli_ctranspose(temp,aptr,*lda,*cols);
+  bli_free_user(temp);
+ }
+ else if ( *trans == 'c' || *trans == 'C')
+ {
+
+  //pre transpose
+  scomplex* temp = (scomplex* ) bli_malloc_user((*rows)*(*lda)*sizeof(scomplex),NULL);
+  bli_ctranspose(aptr,temp,*lda,*rows);
+
+  //bli_ciMatCopy_cr(*cols,*rows,*alpha,temp,*lda,*ldb);
+  for (dim_t i = 0; i < *cols; i++)
+   memcpy(&aptr[i*(*lda)],&temp[i*(*lda)],(*rows)*sizeof(scomplex));
+  bli_ciMatCopy_cr(*cols,*rows,*alpha,aptr,*lda,*ldb);
+
+  //post transpose
+  //bli_ctranspose(temp,aptr,*lda,*cols);
+  bli_free_user(temp);
+ }
+ else if ( *trans == 'r' || *trans == 'R')
+ {
+  bli_ciMatCopy_cr(*rows,*cols,*alpha,aptr,*lda,*ldb);
+ }
+ else
+ {
+  // do nothing
+ }
+ return ;
+}
+
+void zimatcopy_ (f77_char* trans, f77_int* rows, f77_int* cols, const dcomplex* alpha,dcomplex* aptr, f77_int* lda, f77_int* ldb)
+{
+ //bli_init_once();
+ if ( !(*trans == 'n' || *trans == 'N' ||
+  *trans == 't' || *trans == 'T' ||
+  *trans == 'c' || *trans == 'C' ||
+  *trans == 'r' || *trans == 'R'))
+ {
+  bli_print_msg( " Invalid trans  setting zimatcopy_() .", __FILE__, __LINE__ );
+  return ;
+ }
+
+ if ( *rows <= 0 || *cols <= 0 || alpha == NULL || aptr == NULL || *lda < 1 || *ldb < 1)
+ {
+  bli_print_msg( " Invalid function parameters dimatcopy_() .", __FILE__, __LINE__ );
+  return ;
+ }
+
+ if ( *trans == 'n' || *trans == 'N')
+ {
+  bli_ziMatCopy_cn(*rows,*cols,*alpha,aptr,*lda,*ldb);
+ }
+ else if ( *trans == 't' || *trans == 'T')
+ {
+
+  //pre transpose
+  dcomplex* temp = (dcomplex *) bli_malloc_user((*rows)*(*lda)*sizeof(dcomplex),NULL);
+  bli_ztranspose(aptr,temp,*lda,*rows);
+
+  //bli_ziMatCopy_cn(*cols,*rows,*alpha,temp,*lda,*ldb);
+  for (dim_t i = 0; i < *cols; i++)
+   memcpy(&aptr[i*(*lda)],&temp[i*(*lda)],(*rows)*sizeof(dcomplex));
+  bli_ziMatCopy_cn(*cols,*rows,*alpha,aptr,*lda,*ldb);
+
+  //post transpose
+  //bli_ztranspose(temp,aptr,*lda,*cols);
+  bli_free_user(temp);
+ }
+ else if ( *trans == 'c' || *trans == 'C')
+ {
+  //pre transpose
+  dcomplex* temp = (dcomplex *) bli_malloc_user((*rows)*(*lda)*sizeof(dcomplex),NULL);
+  bli_ztranspose(aptr,temp,*lda,*rows);
+
+  //bli_ziMatCopy_cr(*cols,*rows,*alpha,temp,*lda,*ldb);
+  for (dim_t i = 0; i < *cols; i++)
+   memcpy(&aptr[i*(*lda)],&temp[i*(*lda)],(*rows)*sizeof(scomplex));
+  bli_ziMatCopy_cr(*cols,*rows,*alpha,aptr,*lda,*ldb);
+
+  //post transpose
+  //bli_ztranspose(temp,aptr,*lda,*cols);
+  bli_free_user(temp);
+ }
+ else if ( *trans == 'r' || *trans == 'R')
+ {
+  bli_ziMatCopy_cr(*rows,*cols,*alpha,aptr,*lda,*ldb);
+ }
+ else
+ {
+  // do nothing
+ }
+ return ;
+}
+
+// suffix cn means - column major & non-trans
+static dim_t bli_siMatCopy_cn(dim_t rows,dim_t cols,const float alpha,float* a,dim_t lda, dim_t ldb)
+{
+ dim_t i,j;
+
+ float* s_aptr;
+ float* d_aptr;
+
+ if ( rows <= 0 || cols <= 0 || a == NULL || lda < cols || ldb < cols)
+ {
+  bli_print_msg( " Invalid function parameters bli_siMatCopy_cn() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ 
+ if ( lda == ldb && alpha == 1.0)
+ return (0);
+
+ s_aptr = a;
+ d_aptr = a;
+ if ( alpha == 0.0 )
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    d_aptr[j] = 0.0;
+   }
+   d_aptr += ldb;
+  }
+ return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  for(j=0; j<rows; j++)
+  {
+   d_aptr[j] = alpha * s_aptr[j];
+  }
+  s_aptr += lda;
+  d_aptr += ldb;
+ }
+ return(0);
+}
+
+// suffix cn means - column major & non-trans
+static dim_t bli_diMatCopy_cn(dim_t rows,dim_t cols,const double alpha,double* a,dim_t lda, dim_t ldb)
+{
+ dim_t i,j;
+ double* s_aptr;
+ double* d_aptr;
+
+ if ( rows <= 0 || cols <= 0 || a == NULL || lda < cols || ldb < cols)
+ {
+  bli_print_msg( " Invalid function parameters bli_diMatCopy_cn() .", __FILE__, __LINE__ );
+  return (0);
+ }
+
+ if ( lda == ldb && alpha == 1.0)
+ return (0);
+
+ ldb = cols;
+ s_aptr = a;
+ d_aptr = a;
+ if ( alpha == 0.0 )
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    d_aptr[j] = 0.0;
+   }
+   d_aptr += ldb;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  for(j=0; j<rows; j++)
+  {
+   d_aptr[j] = alpha * s_aptr[j];
+  }
+  s_aptr += lda;
+  d_aptr += ldb;
+ }
+ return(0);
+}
+
+// suffix cn means - column major & non-trans
+static dim_t bli_ciMatCopy_cn(dim_t rows,dim_t cols,const scomplex alpha,scomplex* a,dim_t lda, dim_t ldb)
+{
+ dim_t i,j;
+ scomplex* s_aptr;
+ scomplex* d_aptr;
+
+ if ( rows <= 0 || cols <= 0 || a == NULL || lda < cols || ldb < cols)
+ {
+  bli_print_msg( " Invalid function parameters bli_ciMatCopy_cn() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ s_aptr = a;
+ d_aptr = a;
+ if ( alpha.real == 0.0 && alpha.imag == 0.0 )
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    d_aptr[j].real = 0.0;
+    d_aptr[j].imag = 0.0;
+   }
+   d_aptr += ldb;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  for(j=0; j<rows; j++)
+  {
+   scomplex temp = s_aptr[j];
+   d_aptr[j].real = ( (alpha.real * temp.real ) - ( alpha.imag * temp.imag ) );
+   d_aptr[j].imag = ( (alpha.real * temp.imag ) + ( alpha.imag * temp.real ) );
+   //d_aptr[j].real = ( (alpha.real * s_aptr[j].real ) - ( alpha.imag * s_aptr[j].imag ) );
+   //d_aptr[j].imag = ( (alpha.real * s_aptr[j].imag ) + ( alpha.imag * s_aptr[j].real ) );
+  }
+  s_aptr += lda;
+  d_aptr += ldb;
+ }
+ 
+ return(0);
+}
+
+// suffix cn means - column major & non-trans
+static dim_t bli_ziMatCopy_cn(dim_t rows,dim_t cols,const dcomplex alpha,dcomplex* a,dim_t lda, dim_t ldb)
+{
+ dim_t i,j;
+ dcomplex* s_aptr;
+ dcomplex* d_aptr; 
+
+ if ( rows <= 0 || cols <= 0 || a == NULL || lda < cols || ldb < cols)
+ {
+  bli_print_msg( " Invalid function parameters bli_ziMatCopy_cn() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ s_aptr = a;
+ d_aptr = a;
+ if ( alpha.real == 0.0 && alpha.imag == 0.0 )
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    d_aptr[j].real = 0.0;
+    d_aptr[j].imag = 0.0;
+   }
+   d_aptr += ldb;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  for(j=0; j<rows; j++)
+  {
+   dcomplex temp = s_aptr[j];
+   d_aptr[j].real = ( (alpha.real * temp.real ) - ( alpha.imag * temp.imag ) );
+   d_aptr[j].imag = ( (alpha.real * temp.imag ) + ( alpha.imag * temp.real ) );
+   //d_aptr[j].real = ( (alpha.real * s_aptr[j].real ) - ( alpha.imag * s_aptr[j].imag ) );
+   //d_aptr[j].imag = ( (alpha.real * s_aptr[j].imag ) + ( alpha.imag * s_aptr[j].real ) );
+  }
+  s_aptr += lda;
+  d_aptr += ldb;
+ }
+return(0);
+}
+
+// suffix cr means - column major & conjugate
+static dim_t bli_ciMatCopy_cr(dim_t rows,dim_t cols,const scomplex alpha,scomplex* a,dim_t lda, dim_t ldb)
+{
+ dim_t i,j;
+ scomplex* s_aptr;
+ scomplex* d_aptr;
+
+ if ( rows <= 0 || cols <= 0 || a == NULL || lda < cols || ldb < cols)
+ {
+  bli_print_msg( " Invalid function parameters bli_ciMatCopy_cr() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ s_aptr = a;
+ d_aptr = a;
+ if ( alpha.real == 0.0 && alpha.imag == 0.0 )
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    d_aptr[j].real = 0.0;
+    d_aptr[j].imag = 0.0;
+   }
+   d_aptr += ldb;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  for(j=0; j<rows; j++)
+  {
+   scomplex temp = s_aptr[j];
+   d_aptr[j].real = ( (alpha.real * temp.real ) + ( alpha.imag * temp.imag ) );
+   d_aptr[j].imag = ( (alpha.imag * temp.real ) - ( alpha.real * temp.imag ) );
+   //d_aptr[j].real = ( (alpha.real * s_aptr[j].real ) + ( alpha.imag * s_aptr[j].imag ) );
+   //d_aptr[j].imag = ( (alpha.imag * s_aptr[j].real ) - ( alpha.real * s_aptr[j].imag ) );
+  }
+  s_aptr += lda;
+  d_aptr += ldb;
+ }
+ return(0);
+}
+
+// suffix cr means - column major & conjugate
+static dim_t bli_ziMatCopy_cr(dim_t rows,dim_t cols,const dcomplex alpha,dcomplex* a,dim_t lda, dim_t ldb)
+{
+ dim_t i,j;
+ dcomplex* s_aptr;
+ dcomplex* d_aptr;
+
+ if ( rows <= 0 || cols <= 0 || a == NULL || lda < cols || ldb < cols)
+ {
+  bli_print_msg( " Invalid function parameters bli_ziMatCopy_cr() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ s_aptr = a;
+ d_aptr = a;
+ if ( alpha.real == 0.0 && alpha.imag == 0.0 )
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    d_aptr[j].real = 0.0;
+    d_aptr[j].imag = 0.0;
+   }
+   d_aptr += ldb;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  for(j=0; j<rows; j++)
+  {
+   dcomplex temp = s_aptr[j];
+   d_aptr[j].real = ( (alpha.real * temp.real ) + ( alpha.imag * temp.imag ) );
+   d_aptr[j].imag = ( (alpha.imag * temp.real ) - ( alpha.real * temp.imag ) );
+   //d_aptr[j].real = ( (alpha.real * s_aptr[j].real ) + ( alpha.imag * s_aptr[j].imag ) );
+   //d_aptr[j].imag = ( (alpha.imag * s_aptr[j].real ) - ( alpha.real * s_aptr[j].imag ) );
+  }
+  s_aptr += lda;
+  d_aptr += ldb;
+ }
+return(0);
+}
+
+#endif
diff --git a/frame/compat/bla_imatcopy.h b/frame/compat/bla_imatcopy.h
new file mode 100644
index 0000000000..4b29a212c2
--- /dev/null
+++ b/frame/compat/bla_imatcopy.h
@@ -0,0 +1,49 @@
+/*
+
+   BLIS
+   An object-based framework for developing high-performance BLAS-like
+   libraries.
+
+   Copyright (C) 2020, Advanced Micro Devices, Inc. All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+    - Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    - Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    - Neither the name(s) of the copyright holder(s) nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+//
+// Prototype BLAS-to-BLIS interfaces.
+//
+
+#ifdef BLIS_ENABLE_BLAS
+
+BLIS_EXPORT_BLAS void simatcopy_ (f77_char* trans, f77_int* rows, f77_int* cols, const float* alpha,float* aptr, f77_int* lda, f77_int* ldb);
+
+BLIS_EXPORT_BLAS void dimatcopy_ (f77_char* trans, f77_int* rows, f77_int* cols, const double* alpha,double* aptr, f77_int* lda, f77_int* ldb);
+
+BLIS_EXPORT_BLAS void cimatcopy_ (f77_char* trans, f77_int* rows, f77_int* cols, const scomplex* alpha,scomplex* aptr, f77_int* lda, f77_int* ldb);
+
+BLIS_EXPORT_BLAS void zimatcopy_ (f77_char* trans, f77_int* rows, f77_int* cols, const dcomplex* alpha,dcomplex* aptr, f77_int* lda, f77_int* ldb);
+
+#endif
\ No newline at end of file
diff --git a/frame/compat/bla_omatadd.c b/frame/compat/bla_omatadd.c
new file mode 100644
index 0000000000..7dd9ee333a
--- /dev/null
+++ b/frame/compat/bla_omatadd.c
@@ -0,0 +1,478 @@
+/*
+
+   BLIS
+   An object-based framework for developing high-performance BLAS-like
+   libraries.
+
+   Copyright (C) 2020, Advanced Micro Devices, Inc. All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+    - Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    - Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    - Neither the name(s) of the copyright holder(s) nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "blis.h"
+
+#ifdef BLIS_ENABLE_BLAS
+
+static dim_t bli_soMatAdd_cn(dim_t m,dim_t n,const float alpha,float* aptr,dim_t lda,const float beta,float* bptr,dim_t ldb,float* C,dim_t ldc);
+
+static dim_t bli_doMatAdd_cn(dim_t m,dim_t n,const double alpha,double* aptr,dim_t lda,const double beta,double* bptr,dim_t ldb,double* C,dim_t ldc);
+
+static dim_t bli_coMatAdd_cn(dim_t m,dim_t n,const scomplex alpha,scomplex* aptr,dim_t lda,const scomplex beta,scomplex* bptr,dim_t ldb,scomplex* C,dim_t ldc);
+
+static dim_t bli_zoMatAdd_cn(dim_t m,dim_t n,const dcomplex alpha,dcomplex* aptr,dim_t lda,const dcomplex beta,dcomplex* bptr,dim_t ldb,dcomplex* C,dim_t ldc);
+
+static void bli_stranspose(const float* A,float* B,dim_t cols, dim_t rows);
+
+static void bli_dtranspose(const double* A,double* B,dim_t cols, dim_t rows);
+
+static void bli_ctranspose(const scomplex* A,scomplex* B,dim_t cols, dim_t rows);
+
+static void bli_ztranspose(const dcomplex* A,dcomplex* B,dim_t cols, dim_t rows);
+
+static void bli_cconjugate(scomplex* A,dim_t cols,dim_t rows);
+
+static void bli_zconjugate(dcomplex* A,dim_t cols,dim_t rows);
+
+static void bli_stranspose(const float* A,float* B,dim_t cols, dim_t rows)
+{
+ for (dim_t i = 0; i < cols; i++)
+  for (dim_t j = 0; j < rows; j++)
+   B[j*cols + i] = A[i*rows +j];
+}
+
+static void bli_dtranspose(const double* A,double* B,dim_t cols, dim_t rows)
+{
+ for (dim_t i = 0; i < cols; i++)
+  for (dim_t j = 0; j < rows; j++)
+   B[j*cols + i] = A[i*rows +j];
+}
+
+static void bli_ctranspose(const scomplex* A,scomplex* B,dim_t cols, dim_t rows)
+{
+ for (dim_t i = 0; i < cols; i++)
+  for (dim_t j = 0; j < rows; j++)
+   B[j*cols + i] = A[i*rows +j];
+}
+
+static void bli_ztranspose(const dcomplex* A,dcomplex* B,dim_t cols, dim_t rows)
+{
+ for (dim_t i = 0; i < cols; i++)
+  for (dim_t j = 0; j < rows; j++)
+   B[j*cols + i] = A[i*rows +j];
+}
+
+static void bli_cconjugate(scomplex* A,dim_t cols,dim_t rows)
+{
+ for (dim_t i = 0; i < cols*rows; i++)
+  A[i].imag *=(-1);
+}
+
+static void bli_zconjugate(dcomplex* A,dim_t cols,dim_t rows)
+{
+ for (dim_t i = 0; i < cols*rows; i++)
+  A[i].imag *=(-1);
+}
+
+void somatadd_ (f77_char* transa,f77_char* transb, f77_int* m, f77_int* n, const float* alpha, const float* A, f77_int* lda, const float* beta, const float* B, f77_int* ldb, float* C, f77_int* ldc)
+{
+ //bli_init_once();
+
+ if( alpha == NULL || A == NULL || beta == NULL || B == NULL || C == NULL || *lda < 1 || *ldb < 1 || *ldc < 1 || *m < 1 || *n < 1)
+ {
+  bli_print_msg( " Invalid function parameters somatadd_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( !(*transa == 'n' || *transa == 'N' ||
+  *transa == 't' || *transa == 'T' ||
+  *transa == 'c' || *transa == 'C' ||
+  *transa == 'r' || *transa == 'R'))
+ {
+  bli_print_msg( " Invalid value of transa somatadd_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( !(*transb == 'n' || *transb == 'N' ||
+  *transb == 't' || *transb == 'T' ||
+  *transb == 'c' || *transb == 'C' ||
+  *transb == 'r' || *transb == 'R'))
+ {
+  bli_print_msg( " Invalid value of transb somatadd_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ float* aptr;
+ float* bptr;
+
+ //pre transpose
+ if(*transa == 't' || *transa == 'T' ||
+  *transa == 'c' || *transa == 'C')
+ {
+  aptr = (float *) bli_malloc_user((*m)*(*lda)*sizeof(float),NULL);
+  bli_stranspose(A,aptr,*m,*lda);
+ }
+ else
+ {
+  aptr = (float *)A;
+ }
+
+ if(*transb == 't' || *transb == 'T' ||
+  *transb == 'c' || *transb == 'C')
+ {
+  bptr = (float *) bli_malloc_user((*m)*(*ldb)*sizeof(float),NULL);
+  bli_stranspose(B,bptr,*m,*ldb);
+ }
+ else
+ {
+  bptr = (float *)B;
+ }
+
+ bli_soMatAdd_cn(*m,*n,*alpha,aptr,*lda,*beta,bptr,*ldb,C,*ldc);
+
+ //post transpose
+ if(*transa == 't' || *transa == 'T' ||
+  *transa == 'c' || *transa == 'C')
+ {
+  bli_free_user(aptr);
+ }
+ if(*transb == 't' || *transb == 'T' ||
+  *transb == 'c' || *transb == 'C')
+ {
+  bli_free_user(bptr);
+ }
+ return ;
+}
+
+void domatadd_ (f77_char* transa,f77_char* transb, f77_int* m, f77_int* n, const double* alpha, const double* A, f77_int* lda, const double* beta, const double* B, f77_int* ldb, double* C, f77_int* ldc)
+{
+ //bli_init_once();
+ if( alpha == NULL || A == NULL || beta == NULL || B == NULL || C == NULL || *lda < 1 || *ldb < 1 || *ldc < 1 || *m < 1 || *n < 1)
+ {
+  bli_print_msg( " Invalid function parameters domatadd_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( !(*transa == 'n' || *transa == 'N' ||
+  *transa == 't' || *transa == 'T' ||
+  *transa == 'c' || *transa == 'C' ||
+  *transa == 'r' || *transa == 'R'))
+ {
+  bli_print_msg( " Invalid value of transa domatadd_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( !(*transb == 'n' || *transb == 'N' ||
+  *transb == 't' || *transb == 'T' ||
+  *transb == 'c' || *transb == 'C' ||
+  *transb == 'r' || *transb == 'R'))
+ {
+  bli_print_msg( " Invalid value of transb domatadd_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ double* aptr;
+ double* bptr;
+
+ //pre transpose
+ if(*transa == 't' || *transa == 'T' ||
+  *transa == 'c' || *transa == 'C')
+ {
+  aptr = (double *) bli_malloc_user((*m)*(*lda)*sizeof(double),NULL);
+  bli_dtranspose(A,aptr,*m,*lda);
+ }
+ else
+ {
+  aptr = (double *)A;
+ }
+
+ if(*transb == 't' || *transb == 'T' ||
+  *transb == 'c' || *transb == 'C')
+ {
+  bptr = (double *) bli_malloc_user((*m)*(*ldb)*sizeof(double),NULL);
+  bli_dtranspose(B,bptr,*m,*ldb);
+ }
+ else
+ {
+  bptr = (double *)B;
+ }
+
+ bli_doMatAdd_cn(*m,*n,*alpha,aptr,*lda,*beta,bptr,*ldb,C,*ldc);
+
+ //post transpose
+ if(*transa == 't' || *transa == 'T' ||
+  *transa == 'c' || *transa == 'C')
+ {
+  bli_free_user(aptr);
+ }
+ if(*transb == 't' || *transb == 'T' ||
+  *transb == 'c' || *transb == 'C')
+ {
+  bli_free_user(bptr);
+ }
+ return ;
+}
+
+void comatadd_ (f77_char* transa,f77_char* transb, f77_int* m, f77_int* n, const scomplex* alpha, const scomplex* A, f77_int* lda,const scomplex* beta, scomplex* B, f77_int* ldb, scomplex* C, f77_int* ldc)
+{
+ //bli_init_once();
+ if( alpha == NULL || A == NULL || beta == NULL || B == NULL || C == NULL || *lda < 1 || *ldb < 1 || *ldc < 1 || *m < 1 || *n < 1)
+ {
+  bli_print_msg( " Invalid function parameters comatadd_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( !(*transa == 'n' || *transa == 'N' ||
+  *transa == 't' || *transa == 'T' ||
+  *transa == 'c' || *transa == 'C' ||
+  *transa == 'r' || *transa == 'R'))
+ {
+  bli_print_msg( " Invalid value for transa comatadd_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( !(*transb == 'n' || *transb == 'N' ||
+  *transb == 't' || *transb == 'T' ||
+  *transb == 'c' || *transb == 'C' ||
+  *transb == 'r' || *transb == 'R'))
+ {
+  bli_print_msg( " Invalid value of transb domatadd_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ scomplex* aptr;
+ scomplex* bptr;
+
+ //pre transpose
+ if(*transa == 't' || *transa == 'T' ||
+  *transa == 'c' || *transa == 'C')
+ {
+  aptr = (scomplex *) bli_malloc_user((*m)*(*lda)*sizeof(scomplex),NULL);
+  bli_ctranspose(A,aptr,*m,*lda);
+ }
+ else
+ {
+  aptr = (scomplex*)A;
+ }
+
+ if(*transb == 't' || *transb == 'T' ||
+  *transb == 'c' || *transb == 'C')
+ {
+  bptr = (scomplex *) bli_malloc_user((*m)*(*ldb)*sizeof(scomplex),NULL);
+  bli_ctranspose(B,bptr,*m,*ldb);
+ }
+ else
+ {
+  bptr = (scomplex*)B;
+ }
+
+ // If Conjugate
+ if( *transa == 'c' || *transa == 'C' ||
+  *transa == 'r' || *transa == 'R')
+ {
+  bli_cconjugate(aptr,*m,*lda);
+ }
+
+ if( *transb == 'c' || *transb == 'C' ||
+  *transb == 'r' || *transb == 'R')
+ {
+  bli_cconjugate(bptr,*m,*ldb);
+ }
+
+ bli_coMatAdd_cn(*m,*n,*alpha,aptr,*lda,*beta,bptr,*ldb,C,*ldc);
+
+ //post transpose
+ if(*transa == 't' || *transa == 'T' ||
+  *transa == 'c' || *transa == 'C')
+ {
+  bli_free_user(aptr);
+ }
+ if(*transb == 't' || *transb == 'T' ||
+  *transb == 'c' || *transb == 'C')
+ {
+  bli_free_user(bptr);
+ }
+ return ;
+}
+
+void zomatadd_ (f77_char* transa,f77_char* transb, f77_int* m, f77_int* n, const dcomplex* alpha, const dcomplex* A, f77_int* lda,const dcomplex* beta, dcomplex* B, f77_int* ldb, dcomplex* C, f77_int* ldc)
+{
+ //bli_init_once();
+ if( alpha == NULL || A == NULL || beta == NULL || B == NULL || C == NULL || *lda < 1 || *ldb < 1 || *ldc < 1 || *m < 1 || *n < 1)
+ {
+  bli_print_msg( " Invalid function parameters zomatadd_() .", __FILE__, __LINE__ );
+  return ;
+ }
+
+ if ( !(*transa == 'n' || *transa == 'N' ||
+  *transa == 't' || *transa == 'T' ||
+  *transa == 'c' || *transa == 'C' ||
+  *transa == 'r' || *transa == 'R'))
+ {
+  bli_print_msg( " Invalid value for transa zomatadd_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( !(*transb == 'n' || *transb == 'N' ||
+  *transb == 't' || *transb == 'T' ||
+  *transb == 'c' || *transb == 'C' ||
+  *transb == 'r' || *transb == 'R'))
+ {
+  bli_print_msg( " Invalid value for transb zomatadd_() .", __FILE__, __LINE__ );
+  return ;
+ }
+
+ dcomplex* aptr;
+ dcomplex* bptr;
+
+ //pre transpose
+ if(*transa == 't' || *transa == 'T' ||
+  *transa == 'c' || *transa == 'C')
+ {
+  aptr = (dcomplex *) bli_malloc_user((*m)*(*lda)*sizeof(dcomplex),NULL);
+  bli_ztranspose(A,aptr,*m,*lda);
+ }
+ else
+ {
+  aptr = (dcomplex*)A;
+ }
+
+ if(*transb == 't' || *transb == 'T' ||
+  *transb == 'c' || *transb == 'C')
+ {
+  bptr = (dcomplex *) bli_malloc_user((*m)*(*ldb)*sizeof(dcomplex),NULL);
+  bli_ztranspose(B,bptr,*m,*ldb);
+ }
+ else
+ {
+  bptr = (dcomplex*)B;
+ }
+
+ // If Conjugate
+ if( *transa == 'c' || *transa == 'C' ||
+  *transa == 'r' || *transa == 'R')
+ {
+  bli_zconjugate(aptr,*m,*lda);
+ }
+
+ if( *transb == 'c' || *transb == 'C' ||
+  *transb == 'r' || *transb == 'R')
+ {
+  bli_zconjugate(bptr,*m,*ldb);
+ }
+
+ bli_zoMatAdd_cn(*m,*n,*alpha,aptr,*lda,*beta,bptr,*ldb,C,*ldc);
+
+ //post transpose
+ if(*transa == 't' || *transa == 'T' ||
+  *transa == 'c' || *transa == 'C')
+ {
+  bli_free_user(aptr);
+ }
+ if(*transb == 't' || *transb == 'T' ||
+  *transb == 'c' || *transb == 'C')
+ {
+  bli_free_user(bptr);
+ }
+ return ;
+}
+
+static dim_t bli_soMatAdd_cn(dim_t rows,dim_t cols,const float alpha,float* aptr,dim_t lda,const float beta,float* bptr,dim_t ldb,float* C,dim_t ldc)
+{
+ dim_t i,j;
+ if ( rows <= 0 || cols <= 0 || aptr == NULL || lda < rows || bptr == NULL || ldb < rows || C == NULL || ldc < rows )
+ {
+  bli_print_msg( " Invalid function parameters bli_soMatAdd_cn() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ for ( i=0; i<cols; i++ )
+ {
+  for(j=0; j<rows; j++)
+  {
+   C[j] = ((alpha * aptr[j]) + (beta * bptr[j]));
+  }
+  aptr += lda;
+  bptr += ldb;
+  C += ldc;
+ }
+ return(0);
+}
+
+static dim_t bli_doMatAdd_cn(dim_t rows,dim_t cols,const double alpha,double* aptr,dim_t lda,const double beta,double* bptr,dim_t ldb,double* C,dim_t ldc)
+{
+ dim_t i,j;
+ if ( rows <= 0 || cols <= 0 || aptr == NULL || lda < rows || bptr == NULL || ldb < rows || C == NULL || ldc < rows )
+ {
+  bli_print_msg( " Invalid function parameters bli_doMatAdd_cn() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ for ( i=0; i<cols; i++ )
+ {
+  for(j=0; j<rows; j++)
+  {
+   C[j] = ((alpha * aptr[j]) + (beta * bptr[j]));
+  }
+  aptr += lda;
+  bptr += ldb;
+  C += ldc;
+ }
+ return(0);
+}
+
+static dim_t bli_coMatAdd_cn(dim_t rows,dim_t cols,const scomplex alpha,scomplex* aptr,dim_t lda,const scomplex beta,scomplex* bptr,dim_t ldb,scomplex* C,dim_t ldc)
+{
+ dim_t i,j;
+ if ( rows <= 0 || cols <= 0 || aptr == NULL || lda < rows || bptr == NULL || ldb < rows || C == NULL || ldc < rows )
+ {
+  bli_print_msg( " Invalid function parameters bli_coMatAdd_cn() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ for ( i=0; i<cols; i++ )
+ {
+  for(j=0; j<rows; j++)
+  {
+   //C[j] = ((alpha * aptr[j]) + (beta * bptr[j]));
+   C[j].real = (( (alpha.real * aptr[j].real ) - ( alpha.imag * aptr[j].imag ) ) + ( (beta.real * bptr[j].real ) - ( beta.imag * bptr[j].imag ) ));
+   C[j].imag = (( (alpha.real * aptr[j].imag ) + ( alpha.imag * aptr[j].real ) ) + ( (beta.real * bptr[j].imag ) + ( beta.imag * bptr[j].real ) ));
+  }
+  aptr += lda;
+  bptr += ldb;
+  C += ldc;
+ }
+ return(0);
+}
+
+static dim_t bli_zoMatAdd_cn(dim_t rows,dim_t cols,const dcomplex alpha,dcomplex* aptr,dim_t lda,const dcomplex beta,dcomplex* bptr,dim_t ldb,dcomplex* C,dim_t ldc)
+{
+ dim_t i,j;
+ if ( rows <= 0 || cols <= 0 || aptr == NULL || lda < rows || bptr == NULL || ldb < rows || C == NULL || ldc < rows )
+ {
+  bli_print_msg( " Invalid function parameters bli_zoMatAdd_cn() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ for ( i=0; i<cols; i++ )
+ {
+  for(j=0; j<rows; j++)
+  {
+   C[j].real = (( (alpha.real * aptr[j].real ) - ( alpha.imag * aptr[j].imag ) ) + ( (beta.real * bptr[j].real ) - ( beta.imag * bptr[j].imag ) ));
+   C[j].imag = (( (alpha.real * aptr[j].imag ) + ( alpha.imag * aptr[j].real ) ) + ( (beta.real * bptr[j].imag ) + ( beta.imag * bptr[j].real ) ));
+  }
+  aptr += lda;
+  bptr += ldb;
+  C += ldc;
+ }
+ return(0);
+}
+#endif
diff --git a/frame/compat/bla_omatadd.h b/frame/compat/bla_omatadd.h
new file mode 100644
index 0000000000..2a2b751592
--- /dev/null
+++ b/frame/compat/bla_omatadd.h
@@ -0,0 +1,49 @@
+/*
+
+   BLIS
+   An object-based framework for developing high-performance BLAS-like
+   libraries.
+
+   Copyright (C) 2020, Advanced Micro Devices, Inc. All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+    - Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    - Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    - Neither the name(s) of the copyright holder(s) nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+//
+// Prototype BLAS-to-BLIS interfaces.
+//
+
+#ifdef BLIS_ENABLE_BLAS
+
+BLIS_EXPORT_BLAS void somatadd_ (f77_char* transa,f77_char* transb, f77_int* m, f77_int* n, const float* alpha, const float* A, f77_int* lda, const float* beta, const float* B, f77_int* ldb, float* C, f77_int* ldc);
+
+BLIS_EXPORT_BLAS void domatadd_ (f77_char* transa,f77_char* transb, f77_int* m, f77_int* n, const double* alpha, const double* A, f77_int* lda, const double* beta, const double* B, f77_int* ldb, double* C, f77_int* ldc);
+
+BLIS_EXPORT_BLAS void comatadd_ (f77_char* transa,f77_char* transb, f77_int* m, f77_int* n, const scomplex* alpha, const scomplex* A, f77_int* lda,const scomplex* beta, scomplex* B, f77_int* ldb, scomplex* C, f77_int* ldc);
+
+BLIS_EXPORT_BLAS void zomatadd_ (f77_char* transa,f77_char* transb, f77_int* m, f77_int* n, const dcomplex* alpha, const dcomplex* A, f77_int* lda,const dcomplex* beta, dcomplex* B, f77_int* ldb, dcomplex* C, f77_int* ldc);
+
+#endif
diff --git a/frame/compat/bla_omatcopy.c b/frame/compat/bla_omatcopy.c
new file mode 100644
index 0000000000..ee41ce0550
--- /dev/null
+++ b/frame/compat/bla_omatcopy.c
@@ -0,0 +1,885 @@
+/*
+
+   BLIS
+   An object-based framework for developing high-performance BLAS-like
+   libraries.
+
+   Copyright (C) 2020, Advanced Micro Devices, Inc. All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+    - Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    - Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    - Neither the name(s) of the copyright holder(s) nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "blis.h"
+
+#ifdef BLIS_ENABLE_BLAS
+
+static dim_t bli_soMatCopy_cn(dim_t rows,dim_t cols,const float alpha,const float* a,dim_t lda,float* b,dim_t ldb);
+
+static dim_t bli_soMatCopy_ct(dim_t rows,dim_t cols,const float alpha,const float* a,dim_t lda,float* b,dim_t ldb);
+
+static dim_t bli_doMatCopy_cn(dim_t rows,dim_t cols,const double alpha,const double* a,dim_t lda,double* b,dim_t ldb);
+
+static dim_t bli_doMatCopy_ct(dim_t rows,dim_t cols,const double alpha,const double* a,dim_t lda,double* b,dim_t ldb);
+
+static dim_t bli_coMatCopy_cn(dim_t rows,dim_t cols,const scomplex alpha,const scomplex* a,dim_t lda,scomplex* b,dim_t ldb);
+
+static dim_t bli_coMatCopy_ct(dim_t rows,dim_t cols,const scomplex alpha,const scomplex* a,dim_t lda,scomplex* b,dim_t ldb);
+
+static dim_t bli_coMatCopy_cr(dim_t rows,dim_t cols,const scomplex alpha,const scomplex* a,dim_t lda,scomplex* b,dim_t ldb);
+
+static dim_t bli_coMatCopy_cc(dim_t rows,dim_t cols,const scomplex alpha,const scomplex* a,dim_t lda,scomplex* b,dim_t ldb);
+
+static dim_t bli_zoMatCopy_cn(dim_t rows,dim_t cols,const dcomplex alpha,const dcomplex* a,dim_t lda,dcomplex* b,dim_t ldb);
+
+static dim_t bli_zoMatCopy_ct(dim_t rows,dim_t cols,const dcomplex alpha,const dcomplex* a,dim_t lda,dcomplex* b,dim_t ldb);
+
+static dim_t bli_zoMatCopy_cr(dim_t rows,dim_t cols,const dcomplex alpha,const dcomplex* a,dim_t lda,dcomplex* b,dim_t ldb);
+
+static dim_t bli_zoMatCopy_cc(dim_t rows,dim_t cols,const dcomplex alpha,const dcomplex* a,dim_t lda,dcomplex* b,dim_t ldb);
+
+void somatcopy_ (f77_char* trans, f77_int* rows, f77_int* cols, const float* alpha, const float* aptr, f77_int* lda, float* bptr, f77_int* ldb)
+{
+ if ( !(*trans == 'n' || *trans == 'N' ||
+  *trans == 't' || *trans == 'T' ||
+  *trans == 'c' || *trans == 'C' ||
+  *trans == 'r' || *trans == 'R'))
+ {
+  bli_print_msg( " Invalid value of trans parameter in somatcopy_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( *rows <= 0 || *cols <= 0 || alpha == NULL || aptr == NULL || bptr == NULL || *lda < 1 || *ldb < 1 )
+ {
+  bli_print_msg( " Invalid function parameter in somatcopy_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( *trans == 'n' || *trans == 'N')
+ {
+  bli_soMatCopy_cn(*rows,*cols,*alpha,aptr,*lda,bptr,*ldb);
+ }
+ else if ( *trans == 't' || *trans == 'T')
+ {
+  bli_soMatCopy_ct(*rows,*cols,*alpha,aptr,*lda,bptr,*ldb);
+ }
+ else if ( *trans == 'c' || *trans == 'C')
+ {
+  bli_soMatCopy_ct(*rows,*cols,*alpha,aptr,*lda,bptr,*ldb);
+ }
+ else if ( *trans == 'r' || *trans == 'R')
+ {
+  bli_soMatCopy_cn(*rows,*cols,*alpha,aptr,*lda,bptr,*ldb);
+ }
+ else
+ {
+  // do nothing
+ }
+ return ;
+}
+
+void domatcopy_ (f77_char* trans, f77_int* rows, f77_int* cols, const double* alpha, const double* aptr, f77_int* lda, double* bptr, f77_int* ldb)
+{
+ //bli_init_once();
+ if ( !(*trans == 'n' || *trans == 'N' ||
+  *trans == 't' || *trans == 'T' ||
+  *trans == 'c' || *trans == 'C' ||
+  *trans == 'r' || *trans == 'R'))
+ {
+  bli_print_msg( " Invalid value of trans parameter in domatcopy_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( *rows <= 0 || *cols <= 0 || alpha == NULL || aptr == NULL || bptr == NULL || *lda < 1 || *ldb < 1 )
+ {
+  bli_print_msg( " Invalid function parameter in domatcopy_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( *trans == 'n' || *trans == 'N')
+ {
+  bli_doMatCopy_cn(*rows,*cols,*alpha,aptr,*lda,bptr,*ldb);
+ }
+ else if ( *trans == 't' || *trans == 'T')
+ {
+  bli_doMatCopy_ct(*rows,*cols,*alpha,aptr,*lda,bptr,*ldb);
+ }
+ else if ( *trans == 'c' || *trans == 'C')
+ {
+  bli_doMatCopy_ct(*rows,*cols,*alpha,aptr,*lda,bptr,*ldb);
+ }
+ else if ( *trans == 'r' || *trans == 'R')
+ {
+  bli_doMatCopy_cn(*rows,*cols,*alpha,aptr,*lda,bptr,*ldb);
+ }
+ else
+ {
+  // do nothing
+ }
+ return ;
+}
+
+void comatcopy_ (f77_char* trans, f77_int* rows, f77_int* cols, const scomplex* alpha, const scomplex* aptr, f77_int* lda, scomplex* bptr, f77_int* ldb)
+{
+ //bli_init_once();
+ if ( !(*trans == 'n' || *trans == 'N' ||
+  *trans == 't' || *trans == 'T' ||
+  *trans == 'c' || *trans == 'C' ||
+  *trans == 'r' || *trans == 'R'))
+ {
+  bli_print_msg( " Invalid value of trans parameter in comatcopy_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( *rows <= 0 || *cols <= 0 || alpha == NULL || aptr == NULL || bptr == NULL || *lda < 1 || *ldb < 1 )
+ {
+  bli_print_msg( " Invalid function parameter in comatcopy_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( *trans == 'n' || *trans == 'N')
+ {
+  bli_coMatCopy_cn(*rows,*cols,*alpha,aptr,*lda,bptr,*ldb);
+ }
+ else if ( *trans == 't' || *trans == 'T')
+ {
+  bli_coMatCopy_ct(*rows,*cols,*alpha,aptr,*lda,bptr,*ldb);
+ }
+ else if ( *trans == 'c' || *trans == 'C')
+ {
+  bli_coMatCopy_cc(*rows,*cols,*alpha,aptr,*lda,bptr,*ldb);
+ }
+ else if ( *trans == 'r' || *trans == 'R')
+ {
+  bli_coMatCopy_cr(*rows,*cols,*alpha,aptr,*lda,bptr,*ldb);
+ }
+ else
+ {
+  // do nothing
+ }
+ return ;
+}
+
+void zomatcopy_ (f77_char* trans, f77_int* rows, f77_int* cols, const dcomplex* alpha, const dcomplex* aptr, f77_int* lda, dcomplex* bptr, f77_int* ldb)
+{
+ //bli_init_once();
+ if ( !(*trans == 'n' || *trans == 'N' ||
+  *trans == 't' || *trans == 'T' ||
+  *trans == 'c' || *trans == 'C' ||
+  *trans == 'r' || *trans == 'R'))
+ {
+  bli_print_msg( " Invalid value of trans parameter in zomatcopy_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( *rows <= 0 || *cols <= 0 || alpha == NULL || aptr == NULL || bptr == NULL || *lda < 1 || *ldb < 1 )
+ {
+  bli_print_msg( " Invalid function parameter in zomatcopy_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( *trans == 'n' || *trans == 'N')
+ {
+  bli_zoMatCopy_cn(*rows,*cols,*alpha,aptr,*lda,bptr,*ldb);
+ }
+ else if ( *trans == 't' || *trans == 'T')
+ {
+  bli_zoMatCopy_ct(*rows,*cols,*alpha,aptr,*lda,bptr,*ldb);
+ }
+ else if ( *trans == 'c' || *trans == 'C')
+ {
+  bli_zoMatCopy_cc(*rows,*cols,*alpha,aptr,*lda,bptr,*ldb);
+ }
+ else if ( *trans == 'r' || *trans == 'R')
+ {
+  bli_zoMatCopy_cr(*rows,*cols,*alpha,aptr,*lda,bptr,*ldb);
+ }
+ else
+ {
+  // do nothing
+ }
+ return ;
+}
+
+// suffix cn means - column major & non-trans
+static dim_t bli_soMatCopy_cn(dim_t rows,dim_t cols,const float alpha,const float* a,dim_t lda,float* b,dim_t ldb)
+{
+ dim_t i,j;
+ const float* aptr;
+ float* bptr;
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || lda < rows || ldb < rows )
+ {
+  bli_print_msg( " Invalid function parameter in bli_soMatCopy_cn() .", __FILE__, __LINE__ );
+  return (0);
+ }
+
+ aptr = a;
+ bptr = b;
+
+ if ( alpha == 0.0 )
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    bptr[j] = 0.0;
+   }
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ if ( alpha == 1.0 )
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    bptr[j] = aptr[j];
+   }
+   aptr += lda;
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  for(j=0; j<rows; j++)
+  {
+   bptr[j] = alpha * aptr[j];
+  }
+  aptr += lda;
+  bptr += ldb;
+ }
+ return(0);
+}
+
+// suffix cn means - column major & non-trans
+static dim_t bli_doMatCopy_cn(dim_t rows,dim_t cols,const double alpha,const double* a,dim_t lda,double* b,dim_t ldb)
+{
+ dim_t i,j;
+ const double* aptr;
+ double* bptr;
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || lda < rows || ldb < rows )
+ {
+  bli_print_msg( " Invalid function parameter in bli_doMatCopy_cn() .", __FILE__, __LINE__ );
+  return (0);
+ }
+
+ aptr = a;
+ bptr = b;
+
+ if ( alpha == 0.0 )
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    bptr[j] = 0.0;
+   }
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ if ( alpha == 1.0 )
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    bptr[j] = aptr[j];
+   }
+   aptr += lda;
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  for(j=0; j<rows; j++)
+  {
+   bptr[j] = alpha * aptr[j];
+  }
+  aptr += lda;
+  bptr += ldb;
+ }
+
+ return(0);
+}
+
+// suffix cn means - column major & non-trans
+static dim_t bli_coMatCopy_cn(dim_t rows,dim_t cols,const scomplex alpha,const scomplex* a,dim_t lda,scomplex* b,dim_t ldb)
+{
+ dim_t i,j;
+ const scomplex* aptr;
+ scomplex* bptr;
+
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || lda < rows || ldb < rows )
+ {
+  bli_print_msg( " Invalid function parameter in bli_coMatCopy_cn() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ aptr = a;
+ bptr = b;
+
+ if ( alpha.real == 0.0 && alpha.imag == 0.0)
+ {
+  for( i=0; i<cols; i++ )
+  {
+   for( j=0; j<rows; j++ )
+   {
+    bptr[j].real = 0.0;
+    bptr[j].imag = 0.0;
+   }
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ if ( alpha.real == 1.0 && alpha.imag == 1.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    bptr[j].real = aptr[j].real - aptr[j].imag;
+    bptr[j].imag = aptr[j].real + aptr[j].imag;
+   }
+   aptr += lda;
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  for(j=0; j<rows; j++)
+  {
+   bptr[j].real = ( (alpha.real * aptr[j].real ) - ( alpha.imag * aptr[j].imag ) );
+   bptr[j].imag = ( (alpha.real * aptr[j].imag ) + ( alpha.imag * aptr[j].real ) );
+  }
+  aptr += lda;
+  bptr += ldb;
+ }
+
+ return(0);
+}
+
+// suffix cn means - column major & non-trans
+static dim_t bli_zoMatCopy_cn(dim_t rows,dim_t cols,const dcomplex alpha,const dcomplex* a,dim_t lda,dcomplex* b,dim_t ldb)
+{
+ dim_t i,j;
+ const dcomplex* aptr;
+ dcomplex* bptr;
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || lda < rows || ldb < rows )
+ {
+  bli_print_msg( " Invalid function parameter in bli_zoMatCopy_cn() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ aptr = a;
+ bptr = b;
+
+ if ( alpha.real == 0.0 && alpha.imag == 0.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    bptr[j].real = 0.0;
+    bptr[j].imag = 0.0;
+   }
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ if ( alpha.real == 1.0 && alpha.imag == 1.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    bptr[j].real = aptr[j].real - aptr[j].imag;
+    bptr[j].imag = aptr[j].real + aptr[j].imag;
+   }
+   aptr += lda;
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  for(j=0; j<rows; j++)
+  {
+   bptr[j].real = ( (alpha.real * aptr[j].real ) - ( alpha.imag * aptr[j].imag ) );
+   bptr[j].imag = ( (alpha.real * aptr[j].imag ) + ( alpha.imag * aptr[j].real ) );
+  }
+  aptr += lda;
+  bptr += ldb;
+ }
+
+ return(0);
+}
+
+// suffix ct means - column major & trans
+static dim_t bli_soMatCopy_ct(dim_t rows,dim_t cols,const float alpha,const float* a,dim_t lda,float* b,dim_t ldb)
+{
+ dim_t i,j;
+ const float* aptr;
+ float* bptr;
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || lda < rows || ldb < rows )
+ //if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || lda < cols || ldb < rows )
+ {
+  bli_print_msg( " Invalid function parameter in bli_soMatCopy_ct() .", __FILE__, __LINE__ );
+  return (0);
+ }
+
+ aptr = a;
+
+ if ( alpha == 0.0 )
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i];
+   for(j=0; j<rows; j++)
+   {
+    bptr[j*ldb] = 0.0;
+   }
+  }
+  return(0);
+ }
+
+ if ( alpha == 1.0 )
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i];
+   for(j=0; j<rows; j++)
+   {
+    bptr[j*ldb] = aptr[j];
+   }
+   aptr += lda;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  bptr = &b[i];
+  for(j=0; j<rows; j++)
+  {
+   bptr[j*ldb] = alpha * aptr[j];
+  }
+  aptr += lda;
+ }
+ return(0);
+}
+
+// suffix ct means - column major & trans
+static dim_t bli_doMatCopy_ct(dim_t rows,dim_t cols,const double alpha,const double* a,dim_t lda,double* b,dim_t ldb)
+{
+ dim_t i,j;
+ const double* aptr;
+ double* bptr;
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || lda < rows || ldb < rows )
+ {
+  bli_print_msg( " Invalid function parameter in bli_doMatCopy_ct() .", __FILE__, __LINE__ );
+  return (0);
+ }
+
+ aptr = a;
+
+ if ( alpha == 0.0 )
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i];
+   for(j=0; j<rows; j++)
+   {
+     bptr[j*ldb] = 0.0;
+   }
+  }
+  return(0);
+ }
+
+ if ( alpha == 1.0 )
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i];
+   for(j=0; j<rows; j++)
+   {
+    bptr[j*ldb] = aptr[j];
+   }
+   aptr += lda;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  bptr = &b[i];
+  for(j=0; j<rows; j++)
+  {
+   bptr[j*ldb] = alpha * aptr[j];
+  }
+  aptr += lda;
+ }
+
+ return(0);
+}
+
+// suffix ct means - column major & trans
+static dim_t bli_coMatCopy_ct(dim_t rows,dim_t cols,const scomplex alpha,const scomplex* a,dim_t lda,scomplex* b,dim_t ldb)
+{
+ dim_t i,j;
+ const scomplex* aptr;
+ scomplex* bptr;
+
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || lda < rows || ldb < rows )
+ {
+  bli_print_msg( " Invalid function parameter in bli_coMatCopy_ct() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ aptr = a;
+
+ if ( alpha.real == 0.0 && alpha.imag == 0.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i];
+   for(j=0; j<rows; j++)
+   {
+    bptr[j*ldb].real = 0.0;
+    bptr[j*ldb].imag = 0.0;
+   }
+  }
+  return(0);
+ }
+
+ if ( alpha.real == 1.0 && alpha.imag == 1.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i];
+   for(j=0; j<rows; j++)
+   {
+    bptr[j*ldb].real = aptr[j].real - aptr[j].imag;
+    bptr[j*ldb].imag = aptr[j].real + aptr[j].imag;
+   }
+   aptr += lda;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  bptr = &b[i];
+  for(j=0; j<rows; j++)
+  {
+   bptr[j*ldb].real = ( (alpha.real * aptr[j].real ) - ( alpha.imag * aptr[j].imag ) );
+   bptr[j*ldb].imag = ( (alpha.real * aptr[j].imag ) + ( alpha.imag * aptr[j].real ) );
+  }
+  aptr += lda;
+ }
+ return(0);
+}
+
+// suffix ct means - column major & trans
+static dim_t bli_zoMatCopy_ct(dim_t rows,dim_t cols,const dcomplex alpha,const dcomplex* a,dim_t lda,dcomplex* b,dim_t ldb)
+{
+ dim_t i,j;
+ const dcomplex* aptr;
+ dcomplex* bptr;
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || lda < rows || ldb < rows )
+ {
+  bli_print_msg( " Invalid function parameter in bli_zoMatCopy_ct() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ aptr = a;
+
+ if ( alpha.real == 0.0 && alpha.imag == 0.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i];
+   for(j=0; j<rows; j++)
+   {
+    bptr[j*ldb].real = 0.0;
+    bptr[j*ldb].imag = 0.0;
+   }
+  }
+  return(0);
+ }
+
+ if ( alpha.real == 1.0 && alpha.imag == 1.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i];
+   for(j=0; j<rows; j++)
+   {
+    bptr[j*ldb].real = aptr[j].real - aptr[j].imag;
+    bptr[j*ldb].imag = aptr[j].real + aptr[j].imag;
+   }
+   aptr += lda;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  bptr = &b[i];
+  for(j=0; j<rows; j++)
+  {
+   bptr[j*ldb].real = ( (alpha.real * aptr[j].real ) - ( alpha.imag * aptr[j].imag ) );
+   bptr[j*ldb].imag = ( (alpha.real * aptr[j].imag ) + ( alpha.imag * aptr[j].real ) );
+  }
+  aptr += lda;
+ }
+ return(0);
+}
+
+// suffix cr means - column major & conjugate
+static dim_t bli_coMatCopy_cr(dim_t rows,dim_t cols,const scomplex alpha,const scomplex* a,dim_t lda,scomplex* b,dim_t ldb)
+{
+ dim_t i,j;
+ const scomplex* aptr;
+ scomplex* bptr;
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || lda < rows || ldb < rows )
+ {
+  bli_print_msg( " Invalid function parameter in bli_coMatCopy_cr() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ aptr = a;
+ bptr = b;
+
+ if ( alpha.real == 0.0 && alpha.imag == 0.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    bptr[j].real = 0.0;
+    bptr[j].imag = 0.0;
+   }
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ if ( alpha.real == 1.0 && alpha.imag == 1.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    bptr[j].real = aptr[j].real + aptr[j].imag;
+    bptr[j].imag = aptr[j].real - aptr[j].imag;
+   }
+   aptr += lda;
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  for(j=0; j<rows; j++)
+  {
+   bptr[j].real = ( (alpha.real * aptr[j].real ) + ( alpha.imag * aptr[j].imag ) );
+   bptr[j].imag = ( (alpha.imag * aptr[j].real ) - ( alpha.real * aptr[j].imag ) );
+  }
+  aptr += lda;
+  bptr += ldb;
+ }
+
+ return(0);
+}
+
+// suffix cr means - column major & conjugate
+static dim_t bli_zoMatCopy_cr(dim_t rows,dim_t cols,const dcomplex alpha,const dcomplex* a,dim_t lda,dcomplex* b,dim_t ldb)
+{
+ dim_t i,j;
+ const dcomplex* aptr;
+ dcomplex* bptr;
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || lda < rows || ldb < rows )
+ {
+  bli_print_msg( " Invalid function parameter in bli_zoMatCopy_cr() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ aptr = a;
+ bptr = b;
+
+ if ( alpha.real == 0.0 && alpha.imag == 0.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    bptr[j].real = 0.0;
+    bptr[j].imag = 0.0;
+   }
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ if ( alpha.real == 1.0 && alpha.imag == 1.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    bptr[j].real = aptr[j].real + aptr[j].imag;
+    bptr[j].imag = aptr[j].real - aptr[j].imag;
+   }
+   aptr += lda;
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  for(j=0; j<rows; j++)
+  {
+   bptr[j].real = ( (alpha.real * aptr[j].real ) + ( alpha.imag * aptr[j].imag ) );
+   bptr[j].imag = ( (alpha.imag * aptr[j].real ) - ( alpha.real * aptr[j].imag ) );
+  }
+  aptr += lda;
+  bptr += ldb;
+ }
+
+ return(0);
+}
+
+// suffix cc means - column major & conjugate trans
+static dim_t bli_coMatCopy_cc(dim_t rows,dim_t cols,const scomplex alpha,const scomplex* a,dim_t lda,scomplex* b,dim_t ldb)
+{
+ dim_t i,j;
+ const scomplex* aptr;
+ scomplex* bptr;
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || lda < rows || ldb < rows )
+ {
+  bli_print_msg( " Invalid function parameter in bli_coMatCopy_cc() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ aptr = a;
+
+ if ( alpha.real == 0.0 && alpha.imag == 0.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i];
+   for(j=0; j<rows; j++)
+   {
+    bptr[j*ldb].real = 0.0;
+    bptr[j*ldb].imag = 0.0;
+   }
+  }
+  return(0);
+ }
+
+ if ( alpha.real == 1.0 && alpha.imag == 1.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i];
+   for(j=0; j<rows; j++)
+   {
+    bptr[j*ldb].real = aptr[j].real + aptr[j].imag;
+    bptr[j*ldb].imag = aptr[j].real - aptr[j].imag;
+   }
+   aptr += lda;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  bptr = &b[i];
+  for(j=0; j<rows; j++)
+  {
+   bptr[j*ldb].real = ( (alpha.real * aptr[j].real ) + ( alpha.imag * aptr[j].imag ) );
+   bptr[j*ldb].imag = ( (alpha.imag * aptr[j].real ) - ( alpha.real * aptr[j].imag ) );
+  }
+  aptr += lda;
+ }
+ return(0);
+}
+
+// suffix cc means - column major & conjugate trans
+static dim_t bli_zoMatCopy_cc(dim_t rows,dim_t cols,const dcomplex alpha,const dcomplex* a,dim_t lda,dcomplex* b,dim_t ldb)
+{
+ dim_t i,j;
+ const dcomplex* aptr;
+ dcomplex* bptr;
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || lda < rows || ldb < rows )
+ {
+  bli_print_msg( " Invalid function parameter in bli_zoMatCopy_cc() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ aptr = a;
+
+ if ( alpha.real == 0.0 && alpha.imag == 0.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i];
+   for(j=0; j<rows; j++)
+   {
+    bptr[j*ldb].real = 0.0;
+    bptr[j*ldb].imag = 0.0;
+   }
+  }
+  return(0);
+ }
+
+ if ( alpha.real == 1.0 && alpha.imag == 1.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i];
+   for(j=0; j<rows; j++)
+   {
+    bptr[j*ldb].real = aptr[j].real + aptr[j].imag;
+    bptr[j*ldb].imag = aptr[j].real - aptr[j].imag;
+   }
+   aptr += lda;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  bptr = &b[i];
+  for(j=0; j<rows; j++)
+  {
+   bptr[j*ldb].real = ( (alpha.real * aptr[j].real ) + ( alpha.imag * aptr[j].imag ) );
+   bptr[j*ldb].imag = ( (alpha.imag * aptr[j].real ) - ( alpha.real * aptr[j].imag ) );
+  }
+  aptr += lda;
+ }
+ return(0);
+}
+
+#endif
diff --git a/frame/compat/bla_omatcopy.h b/frame/compat/bla_omatcopy.h
new file mode 100644
index 0000000000..e3c5485003
--- /dev/null
+++ b/frame/compat/bla_omatcopy.h
@@ -0,0 +1,49 @@
+/*
+
+   BLIS
+   An object-based framework for developing high-performance BLAS-like
+   libraries.
+
+   Copyright (C) 2020, Advanced Micro Devices, Inc. All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+    - Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    - Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    - Neither the name(s) of the copyright holder(s) nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+//
+// Prototype BLAS-to-BLIS interfaces.
+//
+
+#ifdef BLIS_ENABLE_BLAS
+
+BLIS_EXPORT_BLAS void somatcopy_ (f77_char* trans, f77_int* rows, f77_int* cols, const float* alpha, const float* aptr, f77_int* lda, float* bptr, f77_int* ldb);
+
+BLIS_EXPORT_BLAS void domatcopy_ (f77_char* trans, f77_int* rows, f77_int* cols, const double* alpha, const double* aptr, f77_int* lda, double* bptr, f77_int* ldb);
+
+BLIS_EXPORT_BLAS void comatcopy_ (f77_char* trans, f77_int* rows, f77_int* cols, const scomplex* alpha, const scomplex* aptr, f77_int* lda, scomplex* bptr, f77_int* ldb);
+
+BLIS_EXPORT_BLAS void zomatcopy_ (f77_char* trans, f77_int* rows, f77_int* cols, const dcomplex* alpha, const dcomplex* aptr, f77_int* lda, dcomplex* bptr, f77_int* ldb);
+
+#endif
\ No newline at end of file
diff --git a/frame/compat/bla_omatcopy2.c b/frame/compat/bla_omatcopy2.c
new file mode 100644
index 0000000000..473884e94b
--- /dev/null
+++ b/frame/compat/bla_omatcopy2.c
@@ -0,0 +1,890 @@
+/*
+
+   BLIS
+   An object-based framework for developing high-performance BLAS-like
+   libraries.
+
+   Copyright (C) 2020, Advanced Micro Devices, Inc. All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+    - Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    - Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    - Neither the name(s) of the copyright holder(s) nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#include "blis.h"
+
+#ifdef BLIS_ENABLE_BLAS
+
+static dim_t bli_soMatCopy2_cn(dim_t rows,dim_t cols,const float alpha,const float* a,dim_t lda,dim_t stridea,float* b,dim_t ldb,dim_t strideb);
+
+static dim_t bli_soMatCopy2_ct(dim_t rows,dim_t cols,const float alpha,const float* a,dim_t lda,dim_t stridea,float* b,dim_t ldb,dim_t strideb);
+
+static dim_t bli_doMatCopy2_cn(dim_t rows,dim_t cols,const double alpha,const double* a,dim_t lda,dim_t stridea,double* b,dim_t ldb,dim_t strideb);
+
+static dim_t bli_doMatCopy2_ct(dim_t rows,dim_t cols,const double alpha,const double* a,dim_t lda,dim_t stridea,double* b,dim_t ldb,dim_t strideb);
+
+static dim_t bli_coMatCopy2_cn(dim_t rows,dim_t cols,const scomplex alpha,const scomplex* a,dim_t lda,dim_t stridea,scomplex* b,dim_t ldb,dim_t strideb);
+
+static dim_t bli_coMatCopy2_ct(dim_t rows,dim_t cols,const scomplex alpha,const scomplex* a,dim_t lda,dim_t stridea,scomplex* b,dim_t ldb,dim_t strideb);
+
+static dim_t bli_coMatCopy2_cr(dim_t rows,dim_t cols,const scomplex alpha,const scomplex* a,dim_t lda,dim_t stridea,scomplex* b,dim_t ldb ,dim_t strideb);
+
+static dim_t bli_coMatCopy2_cc(dim_t rows,dim_t cols,const scomplex alpha,const scomplex* a,dim_t lda,dim_t stridea,scomplex* b,dim_t ldb,dim_t strideb);
+
+static dim_t bli_zoMatCopy2_cn(dim_t rows,dim_t cols,const dcomplex alpha,const dcomplex* a,dim_t lda,dim_t stridea,dcomplex* b,dim_t ldb,dim_t strideb);
+
+static dim_t bli_zoMatCopy2_ct(dim_t rows,dim_t cols,const dcomplex alpha,const dcomplex* a,dim_t lda,dim_t stridea,dcomplex* b,dim_t ldb,dim_t strideb);
+
+static dim_t bli_zoMatCopy2_cr(dim_t rows,dim_t cols,const dcomplex alpha,const dcomplex* a,dim_t lda,dim_t stridea,dcomplex* b,dim_t ldb ,dim_t strideb);
+
+static dim_t bli_zoMatCopy2_cc(dim_t rows,dim_t cols,const dcomplex alpha,const dcomplex* a,dim_t lda,dim_t stridea,dcomplex* b,dim_t ldb,dim_t strideb);
+
+void somatcopy2_ (f77_char* trans, f77_int* rows, f77_int* cols, const float* alpha, const float* aptr, f77_int* lda,f77_int* stridea, float* bptr, f77_int* ldb,f77_int* strideb)
+{
+ //bli_init_once();
+ if ( !(*trans == 'n' || *trans == 'N' ||
+  *trans == 't' || *trans == 'T' ||
+  *trans == 'c' || *trans == 'C' ||
+  *trans == 'r' || *trans == 'R'))
+ {
+  bli_print_msg( " Invalid value of trans in somatcopy2_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( *rows <= 0 || *cols <= 0 || alpha == NULL || aptr == NULL || bptr == NULL || *lda < 1 || *ldb < 1 || *stridea < 1 || *strideb < 1)
+ {
+  bli_print_msg( " Invalid function parameter in somatcopy2_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( *trans == 'n' || *trans == 'N')
+ {
+  bli_soMatCopy2_cn(*rows,*cols,*alpha,aptr,*lda,*stridea,bptr,*ldb,*strideb);
+ }
+ else if ( *trans == 't' || *trans == 'T')
+ {
+  bli_soMatCopy2_ct(*rows,*cols,*alpha,aptr,*lda,*stridea,bptr,*ldb,*strideb);
+ }
+ else if ( *trans == 'c' || *trans == 'C')
+ {
+  bli_soMatCopy2_ct(*rows,*cols,*alpha,aptr,*lda,*stridea,bptr,*ldb,*strideb);
+ }
+ else if ( *trans == 'r' || *trans == 'R')
+ {
+  bli_soMatCopy2_cn(*rows,*cols,*alpha,aptr,*lda,*stridea,bptr,*ldb,*strideb);
+ }
+ else
+ {
+  // do nothing
+ }
+ return ;
+}
+
+void domatcopy2_ (f77_char* trans, f77_int* rows, f77_int* cols, const double* alpha, const double* aptr, f77_int* lda,f77_int* stridea, double* bptr, f77_int* ldb,f77_int* strideb)
+{
+ //bli_init_once();
+ if ( !(*trans == 'n' || *trans == 'N' ||
+  *trans == 't' || *trans == 'T' ||
+  *trans == 'c' || *trans == 'C' ||
+  *trans == 'r' || *trans == 'R'))
+ {
+  bli_print_msg( " Invalid value of trans in domatcopy2_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( *rows <= 0 || *cols <= 0 || alpha == NULL || aptr == NULL || bptr == NULL || *lda < 1 || *ldb < 1 || *stridea < 1 || *strideb < 1)
+ {
+  bli_print_msg( " Invalid function parameter in domatcopy2_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( *trans == 'n' || *trans == 'N')
+ {
+  bli_doMatCopy2_cn(*rows,*cols,*alpha,aptr,*lda,*stridea,bptr,*ldb,*strideb);
+ }
+ else if ( *trans == 't' || *trans == 'T')
+ {
+  bli_doMatCopy2_ct(*rows,*cols,*alpha,aptr,*lda,*stridea,bptr,*ldb,*strideb);
+ }
+ else if ( *trans == 'c' || *trans == 'C')
+ {
+  bli_doMatCopy2_ct(*rows,*cols,*alpha,aptr,*lda,*stridea,bptr,*ldb,*strideb);
+ }
+ else if ( *trans == 'r' || *trans == 'R')
+ {
+  bli_doMatCopy2_cn(*rows,*cols,*alpha,aptr,*lda,*stridea,bptr,*ldb,*strideb);
+ }
+ else
+ {
+  // do nothing
+ }
+ return ;
+}
+
+void comatcopy2_ (f77_char* trans, f77_int* rows, f77_int* cols, const scomplex* alpha, const scomplex* aptr, f77_int* lda,f77_int* stridea, scomplex* bptr, f77_int* ldb,f77_int* strideb)
+{
+ //bli_init_once();
+ if ( !(*trans == 'n' || *trans == 'N' ||
+  *trans == 't' || *trans == 'T' ||
+  *trans == 'c' || *trans == 'C' ||
+  *trans == 'r' || *trans == 'R'))
+ {
+  bli_print_msg( " Invalid value of trans in comatcopy2_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( *rows <= 0 || *cols <= 0 || alpha == NULL || aptr == NULL || bptr == NULL || *lda < 1 || *ldb < 1 || *stridea < 1 || *strideb < 1)
+ {
+  bli_print_msg( " Invalid function parameter in comatcopy2_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( *trans == 'n' || *trans == 'N')
+ {
+  bli_coMatCopy2_cn(*rows,*cols,*alpha,aptr,*lda,*stridea,bptr,*ldb,*strideb);
+ }
+ else if ( *trans == 't' || *trans == 'T')
+ {
+  bli_coMatCopy2_ct(*rows,*cols,*alpha,aptr,*lda,*stridea,bptr,*ldb,*strideb);
+ }
+ else if ( *trans == 'c' || *trans == 'C')
+ {
+  bli_coMatCopy2_cc(*rows,*cols,*alpha,aptr,*lda,*stridea,bptr,*ldb,*strideb);
+ }
+ else if ( *trans == 'r' || *trans == 'R')
+ {
+  bli_coMatCopy2_cr(*rows,*cols,*alpha,aptr,*lda,*stridea,bptr,*ldb,*strideb);
+ }
+ else
+ {
+  // do nothing
+ }
+ return ;
+}
+
+void zomatcopy2_ (f77_char* trans, f77_int* rows, f77_int* cols, const dcomplex* alpha, const dcomplex* aptr, f77_int* lda,f77_int* stridea, dcomplex* bptr, f77_int* ldb,f77_int* strideb)
+{
+ //bli_init_once();
+ if ( !(*trans == 'n' || *trans == 'N' ||
+  *trans == 't' || *trans == 'T' ||
+  *trans == 'c' || *trans == 'C' ||
+  *trans == 'r' || *trans == 'R'))
+ {
+  bli_print_msg( " Invalid value of trans in zomatcopy2_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( *rows <= 0 || *cols <= 0 || alpha == NULL || aptr == NULL || bptr == NULL || *lda < 1 || *ldb < 1 || *stridea < 1 || *strideb < 1)
+ {
+  bli_print_msg( " Invalid function parameter in zomatcopy2_() .", __FILE__, __LINE__ );
+  return ;
+ }
+ if ( *trans == 'n' || *trans == 'N')
+ {
+  bli_zoMatCopy2_cn(*rows,*cols,*alpha,aptr,*lda,*stridea,bptr,*ldb,*strideb);
+ }
+ else if ( *trans == 't' || *trans == 'T')
+ {
+  bli_zoMatCopy2_ct(*rows,*cols,*alpha,aptr,*lda,*stridea,bptr,*ldb,*strideb);
+ }
+ else if ( *trans == 'c' || *trans == 'C')
+ {
+  bli_zoMatCopy2_cc(*rows,*cols,*alpha,aptr,*lda,*stridea,bptr,*ldb,*strideb);
+ }
+ else if ( *trans == 'r' || *trans == 'R')
+ {
+  bli_zoMatCopy2_cr(*rows,*cols,*alpha,aptr,*lda,*stridea,bptr,*ldb,*strideb);
+ }
+ else
+ {
+  // do nothing
+ }
+ return ;
+}
+
+// suffix cn means - column major & non-trans
+static dim_t bli_soMatCopy2_cn(dim_t rows,dim_t cols,const float alpha,const float* a,dim_t lda,dim_t stridea,float* b,dim_t ldb,dim_t strideb)
+{
+ dim_t i,j;
+ const float* aptr;
+ float* bptr;
+
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || stridea < 1 || strideb < 1 || lda < (rows +(rows - 1)*(stridea - 1))|| ldb < (rows +(rows - 1)*(strideb - 1)) )
+ {
+  bli_print_msg( " Invalid function parameter in bli_soMatCopy2_cn() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ aptr = a;
+ bptr = b;
+
+ if ( alpha == 0.0 )
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    bptr[j+((strideb - 1)*j)] = 0.0;
+   }
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ if ( alpha == 1.0 )
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    bptr[j+((strideb - 1)*j)] = aptr[j+((stridea - 1)*j)];
+   }
+   aptr += lda;
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  for(j=0; j<rows; j++)
+  {
+   bptr[j+((strideb - 1)*j)] = alpha * aptr[j+((stridea - 1)*j)];
+  }
+  aptr += lda;
+  bptr += ldb;
+ }
+
+ return(0);
+}
+
+// suffix cn means - column major & non-trans
+static dim_t bli_doMatCopy2_cn(dim_t rows,dim_t cols,const double alpha,const double* a,dim_t lda,dim_t stridea,double* b,dim_t ldb,dim_t strideb)
+{
+ dim_t i,j;
+ const double* aptr;
+ double* bptr;
+
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || stridea < 1 || strideb < 1 || lda < (rows +(rows - 1)*(stridea - 1))|| ldb < (rows +(rows - 1)*(strideb - 1)) )
+ {
+  bli_print_msg( " Invalid function parameter in bli_doMatCopy2_cn() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ aptr = a;
+ bptr = b;
+
+ if ( alpha == 0.0 )
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    bptr[j+((strideb - 1)*j)] = 0.0;
+   }
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ if ( alpha == 1.0 )
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    bptr[j+((strideb - 1)*j)] = aptr[j+((stridea - 1)*j)];
+   }
+   aptr += lda;
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  for(j=0; j<rows; j++)
+  {
+   bptr[j+((strideb - 1)*j)] = alpha * aptr[j+((stridea - 1)*j)];
+  }
+  aptr += lda;
+  bptr += ldb;
+ }
+ return(0);
+}
+
+// suffix cn means - column major & non-trans
+static dim_t bli_coMatCopy2_cn(dim_t rows,dim_t cols,const scomplex alpha,const scomplex* a,dim_t lda,dim_t stridea,scomplex* b,dim_t ldb,dim_t strideb)
+{
+ dim_t i,j;
+ const scomplex* aptr;
+ scomplex* bptr;
+
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || stridea < 1 || strideb < 1 || lda < (rows +(rows - 1)*(stridea - 1))|| ldb < (rows +(rows - 1)*(strideb - 1)) )
+ {
+  bli_print_msg( " Invalid function parameter in bli_coMatCopy2_cn() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ aptr = a;
+ bptr = b;
+
+ if ( alpha.real == 0.0 && alpha.imag == 0.0)
+ {
+  for( i=0; i<cols; i++ )
+  {
+   for( j=0; j<rows; j++ )
+   {
+    bptr[j+((strideb - 1)*j)].real = 0.0;
+    bptr[j+((strideb - 1)*j)].imag = 0.0;
+   }
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ if ( alpha.real == 1.0 && alpha.imag == 1.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    bptr[j+((strideb - 1)*j)].real = aptr[j+((stridea - 1)*j)].real - aptr[j+((stridea - 1)*j)].imag;
+    bptr[j+((strideb - 1)*j)].imag = aptr[j+((stridea - 1)*j)].real + aptr[j+((stridea - 1)*j)].imag;
+   }
+   aptr += lda;
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  for(j=0; j<rows; j++)
+  {
+   bptr[j+((strideb - 1)*j)].real = ( (alpha.real * aptr[j+((stridea - 1)*j)].real ) - ( alpha.imag * aptr[j+((stridea - 1)*j)].imag ) );
+   bptr[j+((strideb - 1)*j)].imag = ( (alpha.real * aptr[j+((stridea - 1)*j)].imag ) + ( alpha.imag * aptr[j+((stridea - 1)*j)].real ) );
+  }
+  aptr += lda;
+  bptr += ldb;
+ }
+ return(0);
+}
+
+// suffix cn means - column major & non-trans
+static dim_t bli_zoMatCopy2_cn(dim_t rows,dim_t cols,const dcomplex alpha,const dcomplex* a,dim_t lda,dim_t stridea,dcomplex* b,dim_t ldb,dim_t strideb)
+{
+ dim_t i,j;
+ const dcomplex* aptr;
+ dcomplex* bptr;
+
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || stridea < 1 || strideb < 1 || lda < (rows +(rows - 1)*(stridea - 1))|| ldb < (rows +(rows - 1)*(strideb - 1)) )
+ {
+  bli_print_msg( " Invalid function parameter in bli_zoMatCopy2_cn() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ aptr = a;
+ bptr = b;
+
+ if ( alpha.real == 0.0 && alpha.imag == 0.0)
+ {
+  for( i=0; i<cols; i++ )
+  {
+   for( j=0; j<rows; j++ )
+   {
+    bptr[j+((strideb - 1)*j)].real = 0.0;
+    bptr[j+((strideb - 1)*j)].imag = 0.0;
+   }
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ if ( alpha.real == 1.0 && alpha.imag == 1.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    bptr[j+((strideb - 1)*j)].real = aptr[j+((stridea - 1)*j)].real - aptr[j+((stridea - 1)*j)].imag;
+    bptr[j+((strideb - 1)*j)].imag = aptr[j+((stridea - 1)*j)].real + aptr[j+((stridea - 1)*j)].imag;
+   }
+   aptr += lda;
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  for(j=0; j<rows; j++)
+  {
+   bptr[j+((strideb - 1)*j)].real = ( (alpha.real * aptr[j+((stridea - 1)*j)].real ) - ( alpha.imag * aptr[j+((stridea - 1)*j)].imag ) );
+   bptr[j+((strideb - 1)*j)].imag = ( (alpha.real * aptr[j+((stridea - 1)*j)].imag ) + ( alpha.imag * aptr[j+((stridea - 1)*j)].real ) );
+  }
+  aptr += lda;
+  bptr += ldb;
+ }
+ return(0);
+}
+
+// suffix ct means - column major & trans
+static dim_t bli_soMatCopy2_ct(dim_t rows,dim_t cols,const float alpha,const float* a,dim_t lda,dim_t stridea,float* b,dim_t ldb,dim_t strideb)
+{
+ dim_t i,j;
+ const float* aptr;
+ float* bptr;
+
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || stridea < 1 || strideb < 1 || lda < (rows +(rows - 1)*(stridea - 1))|| ldb < (rows +(rows - 1)*(strideb - 1)) )
+ {
+  bli_print_msg( " Invalid function parameter in bli_soMatCopy2_ct() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ aptr = a;
+
+ if ( alpha == 0.0 )
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i*strideb];
+   for(j=0; j<rows; j++)
+   {
+    bptr[(j*ldb)] = 0.0;
+   }
+  }
+  return(0);
+ }
+
+ if ( alpha == 1.0 )
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i*strideb];
+   for(j=0; j<rows; j++)
+   {
+    bptr[(j*ldb)] = aptr[j+((stridea - 1)*j)];
+   }
+   aptr += lda;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  bptr = &b[i*strideb];
+  for(j=0; j<rows; j++)
+  {
+   bptr[(j*ldb)] = alpha * aptr[j+((stridea - 1)*j)];
+  }
+  aptr += lda;
+ }
+ return(0);
+}
+
+// suffix ct means - column major & trans
+static dim_t bli_doMatCopy2_ct(dim_t rows,dim_t cols,const double alpha,const double* a,dim_t lda,dim_t stridea,double* b,dim_t ldb,dim_t strideb)
+{
+ dim_t i,j;
+ const double* aptr;
+ double* bptr;
+
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || stridea < 1 || strideb < 1 || lda < (rows +(rows - 1)*(stridea - 1))|| ldb < (rows +(rows - 1)*(strideb - 1)) )
+ {
+  bli_print_msg( " Invalid function parameter in bli_doMatCopy2_ct() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ aptr = a;
+
+ if ( alpha == 0.0 )
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i*strideb];
+   for(j=0; j<rows; j++)
+   {
+    bptr[(j*ldb)] = 0.0;
+   }
+  }
+  return(0);
+ }
+
+ if ( alpha == 1.0 )
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i*strideb];
+   for(j=0; j<rows; j++)
+   {
+    bptr[(j*ldb)] = aptr[j+((stridea - 1)*j)];
+   }
+   aptr += lda;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  bptr = &b[i*strideb];
+  for(j=0; j<rows; j++)
+  {
+   bptr[(j*ldb)] = alpha * aptr[j+((stridea - 1)*j)];
+  }
+  aptr += lda;
+ }
+ return(0);
+}
+
+// suffix ct means - column major & trans
+static dim_t bli_coMatCopy2_ct(dim_t rows,dim_t cols,const scomplex alpha,const scomplex* a,dim_t lda,dim_t stridea,scomplex* b,dim_t ldb,dim_t strideb)
+{
+ dim_t i,j;
+ const scomplex* aptr;
+ scomplex* bptr;
+
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || stridea < 1 || strideb < 1 || lda < (rows +(rows - 1)*(stridea - 1))|| ldb < (rows +(rows - 1)*(strideb - 1)) )
+ {
+  bli_print_msg( " Invalid function parameter in bli_coMatCopy2_ct() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ aptr = a;
+
+ if ( alpha.real == 0.0 && alpha.imag == 0.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i*strideb];
+   for(j=0; j<rows; j++)
+   {
+    bptr[j*ldb].real = 0.0;
+    bptr[j*ldb].imag = 0.0;
+   }
+  }
+  return(0);
+ }
+
+ if ( alpha.real == 1.0 && alpha.imag == 1.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i*strideb];
+   for(j=0; j<rows; j++)
+   {
+    bptr[j*ldb].real = aptr[j + ((stridea - 1)*j)].real - aptr[j + ((stridea - 1)*j)].imag;
+    bptr[j*ldb].imag = aptr[j + ((stridea - 1)*j)].real + aptr[j + ((stridea - 1)*j)].imag;
+   }
+   aptr += lda;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  bptr = &b[i*strideb];
+  for(j=0; j<rows; j++)
+  {
+   bptr[j*ldb].real = ( (alpha.real * aptr[j + ((stridea - 1)*j)].real ) - ( alpha.imag * aptr[j + ((stridea - 1)*j)].imag ) );
+   bptr[j*ldb].imag = ( (alpha.real * aptr[j + ((stridea - 1)*j)].imag ) + ( alpha.imag * aptr[j + ((stridea - 1)*j)].real ) );
+  }
+  aptr += lda;
+ }
+ return(0);
+}
+
+// suffix ct means - column major & trans
+static dim_t bli_zoMatCopy2_ct(dim_t rows,dim_t cols,const dcomplex alpha,const dcomplex* a,dim_t lda,dim_t stridea,dcomplex* b,dim_t ldb,dim_t strideb)
+{
+ dim_t i,j;
+ const dcomplex* aptr;
+ dcomplex* bptr;
+
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || stridea < 1 || strideb < 1 || lda < (rows +(rows - 1)*(stridea - 1))|| ldb < (rows +(rows - 1)*(strideb - 1)) )
+ {
+  bli_print_msg( " Invalid function parameter in bli_zoMatCopy2_ct() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ aptr = a;
+
+ if ( alpha.real == 0.0 && alpha.imag == 0.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i*strideb];
+   for(j=0; j<rows; j++)
+   {
+    bptr[j*ldb].real = 0.0;
+    bptr[j*ldb].imag = 0.0;
+   }
+  }
+  return(0);
+ }
+
+ if ( alpha.real == 1.0 && alpha.imag == 1.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i*strideb];
+   for(j=0; j<rows; j++)
+   {
+    bptr[j*ldb].real = aptr[j + ((stridea - 1)*j)].real - aptr[j + ((stridea - 1)*j)].imag;
+    bptr[j*ldb].imag = aptr[j + ((stridea - 1)*j)].real + aptr[j + ((stridea - 1)*j)].imag;
+   }
+   aptr += lda;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  bptr = &b[i*strideb];
+  for(j=0; j<rows; j++)
+  {
+   bptr[j*ldb].real = ( (alpha.real * aptr[j + ((stridea - 1)*j)].real ) - ( alpha.imag * aptr[j + ((stridea - 1)*j)].imag ) );
+   bptr[j*ldb].imag = ( (alpha.real * aptr[j + ((stridea - 1)*j)].imag ) + ( alpha.imag * aptr[j + ((stridea - 1)*j)].real ) );
+  }
+  aptr += lda;
+ }
+ return(0);
+}
+
+// suffix cr means - column major & conjugate
+static dim_t bli_coMatCopy2_cr(dim_t rows,dim_t cols,const scomplex alpha,const scomplex* a,dim_t lda,dim_t stridea,scomplex* b,dim_t ldb,dim_t strideb)
+{
+ dim_t i,j;
+ const scomplex* aptr;
+ scomplex* bptr;
+
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || stridea < 1 || strideb < 1 || lda < (rows +(rows - 1)*(stridea - 1))|| ldb < (rows +(rows - 1)*(strideb - 1)) )
+ {
+  bli_print_msg( " Invalid function parameter in bli_coMatCopy2_cr() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ aptr = a;
+ bptr = b;
+
+ if ( alpha.real == 0.0 && alpha.imag == 0.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    bptr[j + ((strideb - 1)*j)].real = 0.0;
+    bptr[j + ((strideb - 1)*j)].imag = 0.0;
+   }
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ if ( alpha.real == 1.0 && alpha.imag == 1.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    bptr[j + ((strideb - 1)*j)].real = aptr[j + ((stridea - 1)*j)].real + aptr[j + ((stridea - 1)*j)].imag;
+    bptr[j + ((strideb - 1)*j)].imag = aptr[j + ((stridea - 1)*j)].real - aptr[j + ((stridea - 1)*j)].imag;
+   }
+   aptr += lda;
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  for(j=0; j<rows; j++)
+  {
+   bptr[j + ((strideb - 1)*j)].real = ( (alpha.real * aptr[j + ((stridea - 1)*j)].real ) + ( alpha.imag * aptr[j + ((stridea - 1)*j)].imag ) );
+   bptr[j + ((strideb - 1)*j)].imag = ( (alpha.imag * aptr[j + ((stridea - 1)*j)].real ) - ( alpha.real * aptr[j + ((stridea - 1)*j)].imag ) );
+  }
+  aptr += lda;
+  bptr += ldb;
+ }
+
+ return(0);
+}
+
+// suffix cr means - column major & conjugate
+static dim_t bli_zoMatCopy2_cr(dim_t rows,dim_t cols,const dcomplex alpha,const dcomplex* a,dim_t lda,dim_t stridea,dcomplex* b,dim_t ldb,dim_t strideb)
+{
+ dim_t i,j;
+ const dcomplex* aptr;
+ dcomplex* bptr;
+
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || stridea < 1 || strideb < 1 || lda < (rows +(rows - 1)*(stridea - 1))|| ldb < (rows +(rows - 1)*(strideb - 1)) )
+ {
+  bli_print_msg( " Invalid function parameter in bli_zoMatCopy2_cr() .", __FILE__, __LINE__ );
+  return (0);
+ }
+ aptr = a;
+ bptr = b;
+
+ if ( alpha.real == 0.0 && alpha.imag == 0.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    bptr[j + ((strideb - 1)*j)].real = 0.0;
+    bptr[j + ((strideb - 1)*j)].imag = 0.0;
+   }
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ if ( alpha.real == 1.0 && alpha.imag == 1.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   for(j=0; j<rows; j++)
+   {
+    bptr[j + ((strideb - 1)*j)].real = aptr[j + ((stridea - 1)*j)].real + aptr[j + ((stridea - 1)*j)].imag;
+    bptr[j + ((strideb - 1)*j)].imag = aptr[j + ((stridea - 1)*j)].real - aptr[j + ((stridea - 1)*j)].imag;
+   }
+   aptr += lda;
+   bptr += ldb;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  for(j=0; j<rows; j++)
+  {
+   bptr[j + ((strideb - 1)*j)].real = ( (alpha.real * aptr[j + ((stridea - 1)*j)].real ) + ( alpha.imag * aptr[j + ((stridea - 1)*j)].imag ) );
+   bptr[j + ((strideb - 1)*j)].imag = ( (alpha.imag * aptr[j + ((stridea - 1)*j)].real ) - ( alpha.real * aptr[j + ((stridea - 1)*j)].imag ) );
+  }
+  aptr += lda;
+  bptr += ldb;
+ }
+
+ return(0);
+}
+
+// suffix cc means - column major & conjugate-trans
+static dim_t bli_coMatCopy2_cc(dim_t rows,dim_t cols,const scomplex alpha,const scomplex* a,dim_t lda,dim_t stridea,scomplex* b,dim_t ldb,dim_t strideb)
+{
+ dim_t i,j;
+ const scomplex* aptr;
+ scomplex* bptr;
+
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || stridea < 1 || strideb < 1 || lda < (rows +(rows - 1)*(stridea - 1))|| ldb < (rows +(rows - 1)*(strideb - 1)) )
+ {
+  bli_print_msg( " Invalid function parameter in bli_coMatCopy2_cc() .", __FILE__, __LINE__ );
+  return (0);
+ }
+
+ aptr = a;
+
+ if ( alpha.real == 0.0 && alpha.imag == 0.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i*strideb];
+   for(j=0; j<rows; j++)
+   {
+    bptr[j*ldb].real = 0.0;
+    bptr[j*ldb].imag = 0.0;
+   }
+  }
+  return(0);
+ }
+
+ if ( alpha.real == 1.0 && alpha.imag == 1.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i*strideb];
+   for(j=0; j<rows; j++)
+   {
+    bptr[j*ldb].real = aptr[j + ((stridea - 1)*j)].real + aptr[j + ((stridea - 1)*j)].imag;
+    bptr[j*ldb].imag = aptr[j + ((stridea - 1)*j)].real - aptr[j + ((stridea - 1)*j)].imag;
+   }
+   aptr += lda;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  bptr = &b[i*strideb];
+  for(j=0; j<rows; j++)
+  {
+   bptr[j*ldb].real = ( (alpha.real * aptr[j + ((stridea - 1)*j)].real ) + ( alpha.imag * aptr[j + ((stridea - 1)*j)].imag ) );
+   bptr[j*ldb].imag = ( (alpha.imag * aptr[j + ((stridea - 1)*j)].real ) - ( alpha.real * aptr[j + ((stridea - 1)*j)].imag ) );
+  }
+  aptr += lda;
+ }
+ return(0);
+}
+
+// suffix cc means - column major & conjugate-trans
+static dim_t bli_zoMatCopy2_cc(dim_t rows,dim_t cols,const dcomplex alpha,const dcomplex* a,dim_t lda,dim_t stridea,dcomplex* b,dim_t ldb,dim_t strideb)
+{
+ dim_t i,j;
+ const dcomplex* aptr;
+ dcomplex* bptr;
+
+ if ( rows <= 0 || cols <= 0 || a == NULL || b == NULL || stridea < 1 || strideb < 1 || lda < (rows +(rows - 1)*(stridea - 1))|| ldb < (rows +(rows - 1)*(strideb - 1)) )
+ {
+  bli_print_msg( " Invalid function parameter in bli_zoMatCopy2_cc() .", __FILE__, __LINE__ );
+  return (0);
+ }
+
+ aptr = a;
+
+ if ( alpha.real == 0.0 && alpha.imag == 0.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i*strideb];
+   for(j=0; j<rows; j++)
+   {
+    bptr[j*ldb].real = 0.0;
+    bptr[j*ldb].imag = 0.0;
+   }
+  }
+  return(0);
+ }
+
+ if ( alpha.real == 1.0 && alpha.imag == 1.0)
+ {
+  for ( i=0; i<cols ; i++ )
+  {
+   bptr = &b[i*strideb];
+   for(j=0; j<rows; j++)
+   {
+    bptr[j*ldb].real = aptr[j + ((stridea - 1)*j)].real + aptr[j + ((stridea - 1)*j)].imag;
+    bptr[j*ldb].imag = aptr[j + ((stridea - 1)*j)].real - aptr[j + ((stridea - 1)*j)].imag;
+   }
+   aptr += lda;
+  }
+  return(0);
+ }
+
+ for ( i=0; i<cols ; i++ )
+ {
+  bptr = &b[i*strideb];
+  for(j=0; j<rows; j++)
+  {
+   bptr[j*ldb].real = ( (alpha.real * aptr[j + ((stridea - 1)*j)].real ) + ( alpha.imag * aptr[j + ((stridea - 1)*j)].imag ) );
+   bptr[j*ldb].imag = ( (alpha.imag * aptr[j + ((stridea - 1)*j)].real ) - ( alpha.real * aptr[j + ((stridea - 1)*j)].imag ) );
+  }
+  aptr += lda;
+ }
+ return(0);
+}
+
+#endif
diff --git a/frame/compat/bla_omatcopy2.h b/frame/compat/bla_omatcopy2.h
new file mode 100644
index 0000000000..a35f0aefb0
--- /dev/null
+++ b/frame/compat/bla_omatcopy2.h
@@ -0,0 +1,50 @@
+/*
+
+   BLIS
+   An object-based framework for developing high-performance BLAS-like
+   libraries.
+
+   Copyright (C) 2020, Advanced Micro Devices, Inc. All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+    - Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    - Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    - Neither the name(s) of the copyright holder(s) nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+
+//
+// Prototype BLAS-to-BLIS interfaces.
+//
+
+#ifdef BLIS_ENABLE_BLAS
+
+BLIS_EXPORT_BLAS void somatcopy2_ (f77_char* trans, f77_int* rows, f77_int* cols, const float* alpha, const float* aptr, f77_int* lda,f77_int* stridea, float* bptr, f77_int* ldb,f77_int* strideb);
+
+BLIS_EXPORT_BLAS void domatcopy2_ (f77_char* trans, f77_int* rows, f77_int* cols, const double* alpha, const double* aptr, f77_int* lda,f77_int* stridea, double* bptr, f77_int* ldb,f77_int* strideb);
+
+BLIS_EXPORT_BLAS void comatcopy2_ (f77_char* trans, f77_int* rows, f77_int* cols, const scomplex* alpha, const scomplex* aptr, f77_int* lda,f77_int* stridea, scomplex* bptr, f77_int* ldb,f77_int* strideb);
+
+BLIS_EXPORT_BLAS void zomatcopy2_ (f77_char* trans, f77_int* rows, f77_int* cols, const dcomplex* alpha, const dcomplex* aptr, f77_int* lda,f77_int* stridea, dcomplex* bptr, f77_int* ldb,f77_int* strideb);
+
+#endif
\ No newline at end of file
diff --git a/frame/compat/bli_blas.h b/frame/compat/bli_blas.h
index 1ce976453e..11fdef3e45 100644
--- a/frame/compat/bli_blas.h
+++ b/frame/compat/bli_blas.h
@@ -199,6 +199,12 @@
 #include "bla_trsm_check.h"
 #include "bla_gemmt_check.h"
 
+// -- Transpose and Copy Routines --
+#include "bla_omatadd.h"
+#include "bla_omatcopy.h"
+#include "bla_omatcopy2.h"
+#include "bla_imatcopy.h"
+
 // -- Fortran-compatible APIs to BLIS functions --
 
 #include "b77_thread.h"
diff --git a/test/Makefile b/test/Makefile
index bbd817f2d2..11e0b0ed4d 100644
--- a/test/Makefile
+++ b/test/Makefile
@@ -145,7 +145,8 @@ CFLAGS         += -I$(TEST_SRC_PATH)
 # Define the operations we will test.
 TEST_OPS := dotv axpyv \
             gemv ger hemv her her2 trmv trsv \
-            gemm hemm herk her2k trmm trsm
+            gemm hemm herk her2k trmm trsm \
+	    imatcopy omatadd omatcopy omatcopy2 
 
 # Optionally test gemmt, which some libraries might not implement.
 ifeq ($(BUILD_GEMMT),yes)
diff --git a/test/test_imatcopy.c b/test/test_imatcopy.c
new file mode 100644
index 0000000000..fe971647af
--- /dev/null
+++ b/test/test_imatcopy.c
@@ -0,0 +1,163 @@
+/*
+
+   BLIS
+   An object-based framework for developing high-performance BLAS-like
+   libraries.
+
+   Copyright (C) 2020, Advanced Micro Devices, Inc. All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+    - Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    - Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    - Neither the name(s) of the copyright holder(s) nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifdef WIN32
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+#include "blis.h"
+
+int main( int argc, char** argv )
+{
+
+ obj_t data;
+ obj_t alpha;
+ dim_t p;
+ dim_t p_begin, p_end, p_inc;
+ p_begin = 200;
+ p_end   = 2000;
+ p_inc   = 200;
+
+ trans_t  trans;
+ f77_char f77_trans;
+
+ num_t dt;
+ int rows;
+ int cols;
+ //f77_int lda;
+ //f77_int ldb;
+
+ inc_t cs_data;
+
+ double dtime;
+ double dtime_save;
+ double gflops;
+
+ /*rows = 4;
+ cols = 4; 
+ lda = 4; 
+ ldb = 4; 
+*/
+ //cs_data = rows;
+
+ dt = BLIS_DOUBLE;
+ trans = BLIS_NO_TRANSPOSE;
+ bli_param_map_blis_to_netlib_trans( trans, &f77_trans);
+
+ dtime_save = DBL_MAX;
+ for ( p = p_begin; p <= p_end; p += p_inc )
+ {
+
+  rows = p;
+  cols = p; 
+  //lda = p; 
+  //ldb = p; 
+
+  cs_data = rows;
+
+  bli_obj_create( dt, 1, 1, 0, 0, &alpha);
+  bli_obj_create( dt, rows, cols, 1, cs_data, &data );
+
+  bli_randm( &data );
+  bli_setsc(  (2.0/1.0), 0.0, &alpha );
+
+  dtime = bli_clock();
+
+  if ( bli_is_float( dt ) )
+  {
+   f77_int  rows_p     = bli_obj_length( &data);
+   f77_int  cols_p     = bli_obj_width( &data);
+
+   f77_int  lda    = bli_obj_col_stride( &data);
+   f77_int  ldb    = bli_obj_col_stride( &data);
+
+   float*   alpha_p = bli_obj_buffer( &alpha );
+   float*   a_p     = bli_obj_buffer( &data);
+
+   simatcopy_ (&f77_trans, &rows_p, &cols_p, alpha_p, a_p, &lda, &ldb);
+  }
+  else if ( bli_is_double( dt ) )
+  {
+   f77_int  rows_p     = bli_obj_length( &data);
+   f77_int  cols_p     = bli_obj_width( &data);
+
+   f77_int  lda    = bli_obj_col_stride( &data);
+   f77_int  ldb    = bli_obj_col_stride( &data);
+
+   double*   alpha_p = bli_obj_buffer( &alpha );
+   double*   a_p     = bli_obj_buffer( &data);
+   dimatcopy_ (&f77_trans, &rows_p, &cols_p, alpha_p, a_p, &lda, &ldb);
+  }
+  else if ( bli_is_scomplex( dt ) )
+  {
+   f77_int  rows_p     = bli_obj_length( &data);
+   f77_int  cols_p     = bli_obj_width( &data);
+
+   f77_int  lda    = bli_obj_col_stride( &data);
+   f77_int  ldb    = bli_obj_col_stride( &data);
+
+   scomplex*   alpha_p = bli_obj_buffer( &alpha );
+   scomplex*   a_p     = bli_obj_buffer( &data);
+
+   cimatcopy_ (&f77_trans, &rows_p, &cols_p, alpha_p, a_p, &lda, &ldb);
+  }
+  else if ( bli_is_dcomplex( dt ) )
+  {
+   f77_int  rows_p     = bli_obj_length( &data);
+   f77_int  cols_p     = bli_obj_width( &data);
+
+   f77_int  lda    = bli_obj_col_stride( &data);
+   f77_int  ldb    = bli_obj_col_stride( &data);
+
+   dcomplex*   alpha_p = bli_obj_buffer( &alpha );
+   dcomplex*   a_p     = bli_obj_buffer( &data);
+
+   zimatcopy_ (&f77_trans, &rows_p, &cols_p, alpha_p, a_p, &lda, &ldb);
+  }
+
+  dtime_save = bli_clock_min_diff( dtime_save, dtime );
+  gflops = ( 2.0 * rows * cols ) / ( dtime_save * 1.0e9 );
+
+  if ( bli_is_complex( dt ) ) gflops *= 4.0;
+
+  printf( "( %2lu, 1:4 ) = [ %4lu %4lu %7.2f ];\n",
+                        ( unsigned long )(p - p_begin)/p_inc + 1,
+                        ( unsigned long )rows,
+                        ( unsigned long )cols, gflops );
+  bli_obj_free( &alpha );
+  bli_obj_free( &data );
+ }
+ return (0);
+}
diff --git a/test/test_omatadd.c b/test/test_omatadd.c
new file mode 100644
index 0000000000..e741b505f9
--- /dev/null
+++ b/test/test_omatadd.c
@@ -0,0 +1,181 @@
+/*
+
+   BLIS
+   An object-based framework for developing high-performance BLAS-like
+   libraries.
+
+   Copyright (C) 2020, Advanced Micro Devices, Inc. All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+    - Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    - Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    - Neither the name(s) of the copyright holder(s) nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifdef WIN32
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+#include "blis.h"
+
+int main( int argc, char** argv )
+{
+
+ obj_t data_aptr;
+ obj_t data_bptr;
+ obj_t data_cptr;
+ obj_t alpha;
+ obj_t beta;
+ dim_t p;
+ dim_t p_begin, p_end, p_inc;
+ p_begin = 200;
+ p_end   = 2000;
+ p_inc   = 200;
+
+ trans_t  transa,transb;
+ f77_char f77_transa,f77_transb;
+ 
+ num_t dt;
+ int rows;
+ int cols;
+
+ inc_t cs_data;
+
+ double dtime;
+ double dtime_save;
+ double gflops;
+
+ dt = BLIS_DOUBLE;
+ transa = BLIS_NO_TRANSPOSE;
+ transb = BLIS_NO_TRANSPOSE;
+ bli_param_map_blis_to_netlib_trans( transa, &f77_transa);
+ bli_param_map_blis_to_netlib_trans( transb, &f77_transb);
+
+ dtime_save = DBL_MAX;
+ for ( p = p_begin; p <= p_end; p += p_inc )
+ {
+
+  rows = p;
+  cols = p; 
+  cs_data = rows;
+
+  bli_obj_create( dt, 1, 1, 0, 0, &alpha);
+  bli_obj_create( dt, 1, 1, 0, 0, &beta);
+  bli_obj_create( dt, rows, cols, 1, cs_data, &data_aptr );
+  bli_obj_create( dt, rows, cols, 1, cs_data, &data_bptr );
+  bli_obj_create( dt, rows, cols, 1, cs_data, &data_cptr );
+
+  bli_randm( &data_aptr );
+  bli_randm( &data_bptr );
+  bli_setsc(  (2.0/1.0), 0.0, &alpha );
+  bli_setsc(  (2.0/1.0), 0.0, &beta );
+
+  dtime = bli_clock();
+
+  if ( bli_is_float( dt ) )
+  {
+   f77_int  rows_p     = bli_obj_length( &data_aptr);
+   f77_int  cols_p     = bli_obj_width( &data_aptr);
+
+   f77_int  lda    = bli_obj_col_stride( &data_aptr);
+   f77_int  ldb    = bli_obj_col_stride( &data_bptr);
+   f77_int  ldc    = bli_obj_col_stride( &data_cptr);
+
+   float*   alpha_p = bli_obj_buffer( &alpha );
+   float*   beta_p = bli_obj_buffer( &beta );
+   float*   a_p     = bli_obj_buffer( &data_aptr);
+   float*   b_p     = bli_obj_buffer( &data_bptr);
+   float*   c_p     = bli_obj_buffer( &data_cptr);
+
+   somatadd_ (&f77_transa,&f77_transb, &rows_p, &cols_p, alpha_p, a_p, &lda, beta_p, b_p, &ldb, c_p, &ldc);
+  }
+  else if ( bli_is_double( dt ) )
+  {
+   f77_int  rows_p     = bli_obj_length( &data_aptr);
+   f77_int  cols_p     = bli_obj_width( &data_aptr);
+
+   f77_int  lda    = bli_obj_col_stride( &data_aptr);
+   f77_int  ldb    = bli_obj_col_stride( &data_bptr);
+   f77_int  ldc    = bli_obj_col_stride( &data_cptr);
+
+   double*   alpha_p = bli_obj_buffer( &alpha );
+   double*   beta_p = bli_obj_buffer( &beta );
+   double*   a_p     = bli_obj_buffer( &data_aptr);
+   double*   b_p     = bli_obj_buffer( &data_bptr);
+   double*   c_p     = bli_obj_buffer( &data_cptr);
+
+   domatadd_ (&f77_transa,&f77_transb, &rows_p, &cols_p, alpha_p, a_p, &lda, beta_p, b_p, &ldb, c_p, &ldc);
+  }
+  else if ( bli_is_scomplex( dt ) )
+  {
+   f77_int  rows_p     = bli_obj_length( &data_aptr);
+   f77_int  cols_p     = bli_obj_width( &data_aptr);
+
+   f77_int  lda    = bli_obj_col_stride( &data_aptr);
+   f77_int  ldb    = bli_obj_col_stride( &data_bptr);
+   f77_int  ldc    = bli_obj_col_stride( &data_cptr);
+
+   scomplex*   alpha_p = bli_obj_buffer( &alpha );
+   scomplex*   beta_p = bli_obj_buffer( &beta );
+   scomplex*   a_p     = bli_obj_buffer( &data_aptr);
+   scomplex*   b_p     = bli_obj_buffer( &data_bptr);
+   scomplex*   c_p     = bli_obj_buffer( &data_cptr);
+
+   comatadd_ (&f77_transa,&f77_transb, &rows_p, &cols_p, alpha_p, a_p, &lda, beta_p, b_p, &ldb, c_p, &ldc);
+  }
+  else if ( bli_is_dcomplex( dt ) )
+  {
+   f77_int  rows_p     = bli_obj_length( &data_aptr);
+   f77_int  cols_p     = bli_obj_width( &data_aptr);
+
+   f77_int  lda    = bli_obj_col_stride( &data_aptr);
+   f77_int  ldb    = bli_obj_col_stride( &data_bptr);
+   f77_int  ldc    = bli_obj_col_stride( &data_cptr);
+
+   dcomplex*   alpha_p = bli_obj_buffer( &alpha );
+   dcomplex*   beta_p = bli_obj_buffer( &beta );
+   dcomplex*   a_p     = bli_obj_buffer( &data_aptr);
+   dcomplex*   b_p     = bli_obj_buffer( &data_bptr);
+   dcomplex*   c_p     = bli_obj_buffer( &data_cptr);
+
+   zomatadd_ (&f77_transa,&f77_transb, &rows_p, &cols_p, alpha_p, a_p, &lda, beta_p, b_p, &ldb, c_p, &ldc);
+  }
+
+  dtime_save = bli_clock_min_diff( dtime_save, dtime );
+  gflops = ( 2.0 * rows * cols ) / ( dtime_save * 1.0e9 );
+
+  if ( bli_is_complex( dt ) ) gflops *= 4.0;
+
+  printf( "( %2lu, 1:4 ) = [ %4lu %4lu %7.2f ];\n",
+                        ( unsigned long )(p - p_begin)/p_inc + 1,
+                        ( unsigned long )rows,
+                        ( unsigned long )cols, gflops );
+  bli_obj_free( &alpha );
+  bli_obj_free( &beta );
+  bli_obj_free( &data_aptr );
+  bli_obj_free( &data_bptr );
+  bli_obj_free( &data_cptr );
+ }
+ return (0);
+}
diff --git a/test/test_omatcopy.c b/test/test_omatcopy.c
new file mode 100644
index 0000000000..87f1177eda
--- /dev/null
+++ b/test/test_omatcopy.c
@@ -0,0 +1,159 @@
+/*
+
+   BLIS
+   An object-based framework for developing high-performance BLAS-like
+   libraries.
+
+   Copyright (C) 2020, Advanced Micro Devices, Inc. All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+    - Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    - Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    - Neither the name(s) of the copyright holder(s) nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifdef WIN32
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+#include "blis.h"
+
+int main( int argc, char** argv )
+{
+
+ obj_t data_aptr;
+ obj_t data_bptr;
+ obj_t alpha;
+ dim_t p;
+ dim_t p_begin, p_end, p_inc;
+ p_begin = 200;
+ p_end   = 2000;
+ p_inc   = 200;
+
+ trans_t  trans;
+ f77_char f77_trans;
+ 
+ num_t dt;
+ int rows;
+ int cols;
+
+ inc_t cs_data;
+
+ double dtime;
+ double dtime_save;
+ double gflops;
+
+ dt = BLIS_DOUBLE;
+ trans = BLIS_NO_TRANSPOSE;
+ bli_param_map_blis_to_netlib_trans( trans, &f77_trans);
+
+ dtime_save = DBL_MAX;
+ for ( p = p_begin; p <= p_end; p += p_inc )
+ {
+
+  rows = p;
+  cols = p; 
+  cs_data = rows;
+
+  bli_obj_create( dt, 1, 1, 0, 0, &alpha);
+  bli_obj_create( dt, rows, cols, 1, cs_data, &data_aptr );
+  bli_obj_create( dt, rows, cols, 1, cs_data, &data_bptr );
+
+  bli_randm( &data_aptr );
+  bli_setsc(  (2.0/1.0), 0.0, &alpha );
+
+  dtime = bli_clock();
+
+  if ( bli_is_float( dt ) )
+  {
+   f77_int  rows_p     = bli_obj_length( &data_aptr);
+   f77_int  cols_p     = bli_obj_width( &data_aptr);
+
+   f77_int  lda    = bli_obj_col_stride( &data_aptr);
+   f77_int  ldb    = bli_obj_col_stride( &data_bptr);
+
+   float*   alpha_p = bli_obj_buffer( &alpha );
+   float*   a_p     = bli_obj_buffer( &data_aptr);
+   float*   b_p     = bli_obj_buffer( &data_bptr);
+
+   somatcopy_ (&f77_trans, &rows_p, &cols_p, alpha_p, a_p, &lda, b_p, &ldb);
+  }
+  else if ( bli_is_double( dt ) )
+  {
+   f77_int  rows_p     = bli_obj_length( &data_aptr);
+   f77_int  cols_p     = bli_obj_width( &data_aptr);
+
+   f77_int  lda    = bli_obj_col_stride( &data_aptr);
+   f77_int  ldb    = bli_obj_col_stride( &data_bptr);
+
+   double*   alpha_p = bli_obj_buffer( &alpha );
+   double*   a_p     = bli_obj_buffer( &data_aptr);
+   double*   b_p     = bli_obj_buffer( &data_bptr);
+
+   domatcopy_ (&f77_trans, &rows_p, &cols_p, alpha_p, a_p, &lda, b_p, &ldb);
+  }
+  else if ( bli_is_scomplex( dt ) )
+  {
+   f77_int  rows_p     = bli_obj_length( &data_aptr);
+   f77_int  cols_p     = bli_obj_width( &data_aptr);
+
+   f77_int  lda    = bli_obj_col_stride( &data_aptr);
+   f77_int  ldb    = bli_obj_col_stride( &data_bptr);
+
+   scomplex*   alpha_p = bli_obj_buffer( &alpha );
+   scomplex*   a_p     = bli_obj_buffer( &data_aptr);
+   scomplex*   b_p     = bli_obj_buffer( &data_bptr);
+
+   comatcopy_ (&f77_trans, &rows_p, &cols_p, alpha_p, a_p, &lda, b_p, &ldb);
+  }
+  else if ( bli_is_dcomplex( dt ) )
+  {
+   f77_int  rows_p     = bli_obj_length( &data_aptr);
+   f77_int  cols_p     = bli_obj_width( &data_aptr);
+
+   f77_int  lda    = bli_obj_col_stride( &data_aptr);
+   f77_int  ldb    = bli_obj_col_stride( &data_bptr);
+
+   dcomplex*   alpha_p = bli_obj_buffer( &alpha );
+   dcomplex*   a_p     = bli_obj_buffer( &data_aptr);
+   dcomplex*   b_p     = bli_obj_buffer( &data_bptr);
+
+   zomatcopy_ (&f77_trans, &rows_p, &cols_p, alpha_p, a_p, &lda, b_p, &ldb);
+  }
+
+  dtime_save = bli_clock_min_diff( dtime_save, dtime );
+  gflops = ( 2.0 * rows * cols ) / ( dtime_save * 1.0e9 );
+
+  if ( bli_is_complex( dt ) ) gflops *= 4.0;
+
+  printf( "( %2lu, 1:4 ) = [ %4lu %4lu %7.2f ];\n",
+                        ( unsigned long )(p - p_begin)/p_inc + 1,
+                        ( unsigned long )rows,
+                        ( unsigned long )cols, gflops );
+  bli_obj_free( &alpha );
+  bli_obj_free( &data_aptr );
+  bli_obj_free( &data_bptr );
+ }
+ return (0);
+}
diff --git a/test/test_omatcopy2.c b/test/test_omatcopy2.c
new file mode 100644
index 0000000000..b90b4ae883
--- /dev/null
+++ b/test/test_omatcopy2.c
@@ -0,0 +1,168 @@
+/*
+
+   BLIS
+   An object-based framework for developing high-performance BLAS-like
+   libraries.
+
+   Copyright (C) 2020, Advanced Micro Devices, Inc. All rights reserved.
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions are
+   met:
+    - Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    - Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    - Neither the name(s) of the copyright holder(s) nor the names of its
+      contributors may be used to endorse or promote products derived
+      from this software without specific prior written permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+   HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+#ifdef WIN32
+#include <io.h>
+#else
+#include <unistd.h>
+#endif
+#include "blis.h"
+
+int main( int argc, char** argv )
+{
+
+ obj_t data_aptr;
+ obj_t data_bptr;
+ obj_t alpha;
+ dim_t p;
+ dim_t p_begin, p_end, p_inc;
+ p_begin = 200;
+ p_end   = 2000;
+ p_inc   = 200;
+
+ trans_t  trans;
+ f77_char f77_trans;
+ f77_int stridea;
+ f77_int strideb;
+ 
+ num_t dt;
+ int rows;
+ int cols;
+
+ inc_t cs_data_bptr;
+ inc_t cs_data_aptr;
+
+ double dtime;
+ double dtime_save;
+ double gflops;
+
+ dt = BLIS_DOUBLE;
+ trans = BLIS_NO_TRANSPOSE;
+ bli_param_map_blis_to_netlib_trans( trans, &f77_trans);
+
+ stridea = 1;
+ strideb = 1;
+ dtime_save = DBL_MAX;
+ for ( p = p_begin; p <= p_end; p += p_inc )
+ {
+  rows = p;
+  cols = p; 
+  cs_data_aptr = rows + (rows - 1)*stridea;
+  cs_data_bptr = rows + (rows - 1)*strideb;
+
+  bli_obj_create( dt, 1, 1, 0, 0, &alpha);
+  bli_obj_create( dt, cs_data_aptr, cols, 1, cs_data_aptr, &data_aptr );
+  bli_obj_create( dt, cs_data_bptr, cols, 1, cs_data_bptr, &data_bptr );
+
+  bli_randm( &data_aptr );
+  bli_setsc(  (2.0/1.0), 0.0, &alpha );
+
+  dtime = bli_clock();
+
+  if ( bli_is_float( dt ) )
+  {
+   f77_int  rows_p     = bli_obj_length( &data_aptr);
+   f77_int  cols_p     = bli_obj_width( &data_aptr);
+   rows_p = rows_p - (cols_p - 1)*stridea;
+
+   f77_int  lda    = bli_obj_col_stride( &data_aptr);
+   f77_int  ldb    = bli_obj_col_stride( &data_bptr);
+   
+   float*   alpha_p = bli_obj_buffer( &alpha );
+   float*   a_p     = bli_obj_buffer( &data_aptr);
+   float*   b_p     = bli_obj_buffer( &data_bptr);
+
+   somatcopy2_ (&f77_trans, &rows_p, &cols_p, alpha_p, a_p, &lda, &stridea, b_p, &ldb, &strideb);
+  }
+  else if ( bli_is_double( dt ) )
+  {
+   f77_int  rows_p     = bli_obj_length( &data_aptr);
+   f77_int  cols_p     = bli_obj_width( &data_aptr);
+   rows_p = rows_p - (cols_p - 1)*stridea;
+
+   f77_int  lda    = bli_obj_col_stride( &data_aptr);
+   f77_int  ldb    = bli_obj_col_stride( &data_bptr);
+
+   double*   alpha_p = bli_obj_buffer( &alpha );
+   double*   a_p     = bli_obj_buffer( &data_aptr);
+   double*   b_p     = bli_obj_buffer( &data_bptr);
+
+   domatcopy2_ (&f77_trans, &rows_p, &cols_p, alpha_p, a_p, &lda, &stridea, b_p, &ldb, &strideb);
+  }
+  else if ( bli_is_scomplex( dt ) )
+  {
+   f77_int  rows_p     = bli_obj_length( &data_aptr);
+   f77_int  cols_p     = bli_obj_width( &data_aptr);
+   rows_p = rows_p - (cols_p - 1)*stridea;
+
+   f77_int  lda    = bli_obj_col_stride( &data_aptr);
+   f77_int  ldb    = bli_obj_col_stride( &data_bptr);
+
+   scomplex*   alpha_p = bli_obj_buffer( &alpha );
+   scomplex*   a_p     = bli_obj_buffer( &data_aptr);
+   scomplex*   b_p     = bli_obj_buffer( &data_bptr);
+
+   comatcopy2_ (&f77_trans, &rows_p, &cols_p, alpha_p, a_p, &lda, &stridea, b_p, &ldb, &strideb);
+  }
+  else if ( bli_is_dcomplex( dt ) )
+  {
+   f77_int  rows_p     = bli_obj_length( &data_aptr);
+   f77_int  cols_p     = bli_obj_width( &data_aptr);
+   rows_p = rows_p - (cols_p - 1)*stridea;
+
+   f77_int  lda    = bli_obj_col_stride( &data_aptr);
+   f77_int  ldb    = bli_obj_col_stride( &data_bptr);
+
+   dcomplex*   alpha_p = bli_obj_buffer( &alpha );
+   dcomplex*   a_p     = bli_obj_buffer( &data_aptr);
+   dcomplex*   b_p     = bli_obj_buffer( &data_bptr);
+
+   zomatcopy2_ (&f77_trans, &rows_p, &cols_p, alpha_p, a_p, &lda, &stridea, b_p, &ldb, &strideb);
+  }
+
+  dtime_save = bli_clock_min_diff( dtime_save, dtime );
+  gflops = ( 2.0 * rows * cols ) / ( dtime_save * 1.0e9 );
+
+  if ( bli_is_complex( dt ) ) gflops *= 4.0;
+
+  printf( "( %2lu, 1:4 ) = [ %4lu %4lu %7.2f ];\n",
+                        ( unsigned long )(p - p_begin)/p_inc + 1,
+                        ( unsigned long )rows,
+                        ( unsigned long )cols, gflops );
+  bli_obj_free( &alpha );
+  bli_obj_free( &data_aptr );
+  bli_obj_free( &data_bptr );
+ }
+ return (0);
+}