decompiled_code:
__int64 __fastcall cblas_cgeru(unsigned int a1, int a2, int a3, __int64 a4, __int64 a5, int a6, __int64 a7, char a8, __int64 a9, char a10)
{
__int64 result; // rax
int v11; // [rsp+4h] [rbp-14h] BYREF
int v12; // [rsp+8h] [rbp-10h] BYREF
int v13[3]; // [rsp+Ch] [rbp-Ch] BYREF

v13[0] = a2;
v12 = a3;
v11 = a6;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 == 102 )
{
result = cgeru_(v13, &v12, a4, a5, &v11, a7, &a8, a9, &a10);
}
else if ( a1 == 101 )
{
RowMajorStrg = 1;
result = cgeru_(&v12, v13, a4, a7, &a8, a5, &v11, a9, &a10);
}
else
{
result = cblas_xerbla(1LL, "cblas_cgeru", "Illegal Order setting, %d\n", a1);
}
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func0(unsigned int a1, int a2, int a3, __int64 a4, __int64 a5, int a6, __int64 a7, char a8, __int64 a9, char a10)
{
__int64 result; // rax
int v11; // [rsp+4h] [rbp-14h] BYREF
int v12; // [rsp+8h] [rbp-10h] BYREF
int v13[3]; // [rsp+Ch] [rbp-Ch] BYREF

v13[0] = a2;
v12 = a3;
v11 = a6;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 == 102 )
{
result = cgeru_(v13, &v12, a4, a5, &v11, a7, &a8, a9, &a10);
}
else if ( a1 == 101 )
{
RowMajorStrg = 1;
result = cgeru_(&v12, v13, a4, a7, &a8, a5, &v11, a9, &a10);
}
else
{
result = cblas_xerbla(1LL, "cblas_cgeru", "Illegal Order setting, %d\n", a1);
}
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}

original_code:
void cblas_cgeru(const enum CBLAS_ORDER order, const int M, const int N,
                 const void *alpha, const void *X, const int incX,
                 const void *Y, const int incY, void *A, const int lda)
{
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      cgeru_( &M, &N, alpha, X, &incX, Y, &incY, A,
                      &lda);
   }
   else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      cgeru_( &N, &M, alpha, Y, &incY, X, &incX, A,
                      &lda);
   }
   else cblas_xerbla(1, "cblas_cgeru","Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

canonical_original_code:
void cblas_cgeru(enum CBLAS_ORDER order, int M, int N, void *alpha, void *X, int incX, void *Y, int incY, void *A, int lda)
{
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      cgeru_( &M, &N, alpha, X, &incX, Y, &incY, A,
                      &lda);
   }
   else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      cgeru_( &N, &M, alpha, Y, &incY, X, &incX, A,
                      &lda);
   }
   else cblas_xerbla(1, "cblas_cgeru","Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

variable_types:
X
void *

variable_types: incX int

variable_types:
Y
void *

variable_types: incY int

variable_types:
A
void *

variable_types: lda int


repo: ivanjimenez/ipaap

decompiled_code:
float __fastcall cblas_scasum(int a1, __int64 a2, int a3)
{
int v4; // [rsp+8h] [rbp-20h] BYREF
int v5[4]; // [rsp+Ch] [rbp-1Ch] BYREF
float v6[3]; // [rsp+1Ch] [rbp-Ch] BYREF

v5[0] = a1;
v4 = a3;
scasumsub_(v5, a2, &v4, v6);
return v6[0];
}

canonical_decompiled_code:
float __fastcall func0(int a1, __int64 a2, int a3)
{
int v4; // [rsp+8h] [rbp-20h] BYREF
int v5[4]; // [rsp+Ch] [rbp-1Ch] BYREF
float v6[3]; // [rsp+1Ch] [rbp-Ch] BYREF

v5[0] = a1;
v4 = a3;
scasumsub_(v5, a2, &v4, v6);
return v6[0];
}

original_code:
float cblas_scasum( const int N, const void *X, const int incX)
{
   float asum;
   scasumsub_( &N, X, &incX, &asum);
   return asum;
}

canonical_original_code:
float cblas_scasum(int N, void *X, int incX)
{
   float asum;
   scasumsub_( &N, X, &incX, &asum);
   return asum;
}

variable_types: N int

variable_types: asum float

return_type: float


decompiled_code:
__int64 __fastcall cblas_csyr2k(unsigned int a1, unsigned int a2, unsigned int a3, int a4, int a5, __int64 a6, __int64 a7, char a8, __int64 a9, char a10, __int64 a11, __int64 a12, char a13)
{
__int64 result; // rax
int v14; // [rsp+8h] [rbp-20h] BYREF
int v15[4]; // [rsp+Ch] [rbp-1Ch] BYREF
char v16; // [rsp+1Eh] [rbp-Ah] BYREF
char v17[9]; // [rsp+1Fh] [rbp-9h] BYREF

v15[0] = a4;
v14 = a5;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 == 102 )
{
if ( a2 == 121 )
{
v17[0] = 85;
}
else
{
if ( a2 != 122 )
{
result = cblas_xerbla(2LL, "cblas_csyr2k", "Illegal Uplo setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
v17[0] = 76;
}
switch ( a3 )
{
case 'p':
v16 = 84;
goto LABEL_20;
case 'q':
v16 = 67;
goto LABEL_20;
case 'o':
v16 = 78;
goto LABEL_20;
}
LABEL_22:
result = cblas_xerbla(3LL, "cblas_csyr2k", "Illegal Trans setting, %d\n", a3);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
if ( a1 != 101 )
{
result = cblas_xerbla(1LL, "cblas_csyr2k", "Illegal Order setting, %d\n", a1);
goto LABEL_29;
}
RowMajorStrg = 1;
if ( a2 == 121 )
{
v17[0] = 76;
}
else
{
if ( a2 != 122 )
{
result = cblas_xerbla(3LL, "cblas_csyr2k", "Illegal Uplo setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
v17[0] = 85;
}
if ( a3 == 112 )
{
v16 = 78;
goto LABEL_20;
}
if ( a3 == 113 )
{
v16 = 78;
goto LABEL_20;
}
if ( a3 != 111 )
goto LABEL_22;
v16 = 84;
LABEL_20:
result = csyr2k_(v17, &v16, v15, &v14, a6, a7, &a8, a9, &a10, a11, a12, &a13);
LABEL_29:
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func0(unsigned int a1, unsigned int a2, unsigned int a3, int a4, int a5, __int64 a6, __int64 a7, char a8, __int64 a9, char a10, __int64 a11, __int64 a12, char a13)
{
__int64 result; // rax
int v14; // [rsp+8h] [rbp-20h] BYREF
int v15[4]; // [rsp+Ch] [rbp-1Ch] BYREF
char v16; // [rsp+1Eh] [rbp-Ah] BYREF
char v17[9]; // [rsp+1Fh] [rbp-9h] BYREF

v15[0] = a4;
v14 = a5;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 == 102 )
{
if ( a2 == 121 )
{
v17[0] = 85;
}
else
{
if ( a2 != 122 )
{
result = cblas_xerbla(2LL, "cblas_csyr2k", "Illegal Uplo setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
v17[0] = 76;
}
switch ( a3 )
{
case 'p':
v16 = 84;
goto LABEL_20;
case 'q':
v16 = 67;
goto LABEL_20;
case 'o':
v16 = 78;
goto LABEL_20;
}
LABEL_22:
result = cblas_xerbla(3LL, "cblas_csyr2k", "Illegal Trans setting, %d\n", a3);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
if ( a1 != 101 )
{
result = cblas_xerbla(1LL, "cblas_csyr2k", "Illegal Order setting, %d\n", a1);
goto LABEL_29;
}
RowMajorStrg = 1;
if ( a2 == 121 )
{
v17[0] = 76;
}
else
{
if ( a2 != 122 )
{
result = cblas_xerbla(3LL, "cblas_csyr2k", "Illegal Uplo setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
v17[0] = 85;
}
if ( a3 == 112 )
{
v16 = 78;
goto LABEL_20;
}
if ( a3 == 113 )
{
v16 = 78;
goto LABEL_20;
}
if ( a3 != 111 )
goto LABEL_22;
v16 = 84;
LABEL_20:
result = csyr2k_(v17, &v16, v15, &v14, a6, a7, &a8, a9, &a10, a11, a12, &a13);
LABEL_29:
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}

original_code:
void cblas_csyr2k(const enum CBLAS_ORDER Order, const enum CBLAS_UPLO Uplo,
                  const enum CBLAS_TRANSPOSE Trans, const int N, const int K,
                  const void *alpha, const void *A, const int lda,
                  const void *B, const int ldb, const void *beta,
                  void *C, const int ldc)
{
   char UL, TR;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if( Order == CblasColMajor )
   {
      if( Uplo == CblasUpper) UL='U';
      else if ( Uplo == CblasLower ) UL='L';
      else
      {
         cblas_xerbla(2, "cblas_csyr2k", "Illegal Uplo setting, %d\n", Uplo);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if( Trans == CblasTrans) TR ='T';
      else if ( Trans == CblasConjTrans ) TR='C';
      else if ( Trans == CblasNoTrans ) TR='N';
      else
      {
         cblas_xerbla(3, "cblas_csyr2k", "Illegal Trans setting, %d\n", Trans);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      csyr2k_(&UL, &TR, &N, &K, alpha, A, &lda,
                      B, &ldb, beta, C, &ldc);
   } else if (Order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if( Uplo == CblasUpper) UL='L';
      else if ( Uplo == CblasLower ) UL='U';
      else
      {
         cblas_xerbla(3, "cblas_csyr2k", "Illegal Uplo setting, %d\n", Uplo);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if( Trans == CblasTrans) TR ='N';
      else if ( Trans == CblasConjTrans ) TR='N';
      else if ( Trans == CblasNoTrans ) TR='T';
      else
      {
         cblas_xerbla(3, "cblas_csyr2k", "Illegal Trans setting, %d\n", Trans);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      csyr2k_(&UL, &TR, &N, &K, alpha, A, &lda, B, &ldb, beta, C, &ldc);
   }
   else cblas_xerbla(1, "cblas_csyr2k", "Illegal Order setting, %d\n", Order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

canonical_original_code:
void cblas_csyr2k(enum CBLAS_ORDER Order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE Trans, int N, int K, void *alpha, void *A, int lda, void *B, int ldb, void *beta, void *C, int ldc)
{
   char UL; char TR;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if( Order == CblasColMajor )
   {
      if( Uplo == CblasUpper) UL='U';
      else if ( Uplo == CblasLower ) UL='L';
      else
      {
         cblas_xerbla(2, "cblas_csyr2k", "Illegal Uplo setting, %d\n", Uplo);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if( Trans == CblasTrans) TR ='T';
      else if ( Trans == CblasConjTrans ) TR='C';
      else if ( Trans == CblasNoTrans ) TR='N';
      else
      {
         cblas_xerbla(3, "cblas_csyr2k", "Illegal Trans setting, %d\n", Trans);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      csyr2k_(&UL, &TR, &N, &K, alpha, A, &lda,
                      B, &ldb, beta, C, &ldc);
   } else if (Order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if( Uplo == CblasUpper) UL='L';
      else if ( Uplo == CblasLower ) UL='U';
      else
      {
         cblas_xerbla(3, "cblas_csyr2k", "Illegal Uplo setting, %d\n", Uplo);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if( Trans == CblasTrans) TR ='N';
      else if ( Trans == CblasConjTrans ) TR='N';
      else if ( Trans == CblasNoTrans ) TR='T';
      else
      {
         cblas_xerbla(3, "cblas_csyr2k", "Illegal Trans setting, %d\n", Trans);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      csyr2k_(&UL, &TR, &N, &K, alpha, A, &lda, B, &ldb, beta, C, &ldc);
   }
   else cblas_xerbla(1, "cblas_csyr2k", "Illegal Order setting, %d\n", Order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

variable_types: enum CBLAS_ORDER { CblasRowMajor=101, CblasColMajor=102 }

variable_types: enum CBLAS_UPLO { CblasUpper=121, CblasLower=122 }

variable_types: enum CBLAS_TRANSPOSE { CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113 }

variable_types: K int

variable_types:
alpha
void *

variable_types:
B
void *

variable_types: ldb int

variable_types:
beta
void *

variable_types:
C
void *

variable_types: ldc int

variable_types: UL char

variable_types: TR char

variable_types: RowMajorStrg int

return_type: void


decompiled_code:
__int64 __fastcall cblas_caxpy(int a1, __int64 a2, __int64 a3, int a4, __int64 a5, int a6)
{
int v7; // [rsp+4h] [rbp-14h] BYREF
int v8; // [rsp+8h] [rbp-10h] BYREF
int v9[3]; // [rsp+Ch] [rbp-Ch] BYREF

v9[0] = a1;
v8 = a4;
v7 = a6;
return caxpy_(v9, a2, a3, &v8, a5, &v7);
}

canonical_decompiled_code:
__int64 __fastcall func0(int a1, __int64 a2, __int64 a3, int a4, __int64 a5, int a6)
{
int v7; // [rsp+4h] [rbp-14h] BYREF
int v8; // [rsp+8h] [rbp-10h] BYREF
int v9[3]; // [rsp+Ch] [rbp-Ch] BYREF

v9[0] = a1;
v8 = a4;
v7 = a6;
return caxpy_(v9, a2, a3, &v8, a5, &v7);
}

original_code:
void cblas_caxpy( const int N, const void *alpha, const void *X,
                       const int incX, void *Y, const int incY)
{
   caxpy_( &N, alpha, X, &incX, Y, &incY);
}

canonical_original_code:
void cblas_caxpy(int N, void *alpha, void *X, int incX, void *Y, int incY)
{
   caxpy_( &N, alpha, X, &incX, Y, &incY);
}

variable_types:
X
void *

variable_types: incX int

variable_types:
Y
void *

variable_types: incY int


decompiled_code:
__int64 __fastcall cblas_dgemv(unsigned int a1, unsigned int a2, int a3, int a4, __int64 a5, int a6, double a7, double a8, __int64 a9, char a10, __int64 a11, char a12)
{
__int64 result; // rax
double v13; // [rsp+0h] [rbp-38h] BYREF
int v14; // [rsp+Ch] [rbp-2Ch] BYREF
double v15; // [rsp+10h] [rbp-28h] BYREF
int v16; // [rsp+18h] [rbp-20h] BYREF
int v17[4]; // [rsp+1Ch] [rbp-1Ch] BYREF
char v18[9]; // [rsp+2Fh] [rbp-9h] BYREF

v17[0] = a3;
v16 = a4;
v15 = a7;
v14 = a6;
v13 = a8;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 != 102 )
{
if ( a1 != 101 )
{
result = cblas_xerbla(1LL, "cblas_dgemv", "Illegal Order setting, %d\n", a1);
goto LABEL_20;
}
RowMajorStrg = 1;
switch ( a2 )
{
case 'o':
v18[0] = 84;
goto LABEL_16;
case 'p':
v18[0] = 78;
goto LABEL_16;
case 'q':
v18[0] = 78;
LABEL_16:
result = dgemv_(v18, &v16, v17, &v15, a5, &v14, a9, &a10, &v13, a11, &a12);
goto LABEL_20;
}
LABEL_14:
result = cblas_xerbla(2LL, "cblas_dgemv", "Illegal TransA setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
switch ( a2 )
{
case 'o':
v18[0] = 78;
break;
case 'p':
v18[0] = 84;
break;
case 'q':
v18[0] = 67;
break;
default:
goto LABEL_14;
}
result = dgemv_(v18, v17, &v16, &v15, a5, &v14, a9, &a10, &v13, a11, &a12);
LABEL_20:
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func0(unsigned int a1, unsigned int a2, int a3, int a4, __int64 a5, int a6, double a7, double a8, __int64 a9, char a10, __int64 a11, char a12)
{
__int64 result; // rax
double v13; // [rsp+0h] [rbp-38h] BYREF
int v14; // [rsp+Ch] [rbp-2Ch] BYREF
double v15; // [rsp+10h] [rbp-28h] BYREF
int v16; // [rsp+18h] [rbp-20h] BYREF
int v17[4]; // [rsp+1Ch] [rbp-1Ch] BYREF
char v18[9]; // [rsp+2Fh] [rbp-9h] BYREF

v17[0] = a3;
v16 = a4;
v15 = a7;
v14 = a6;
v13 = a8;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 != 102 )
{
if ( a1 != 101 )
{
result = cblas_xerbla(1LL, "cblas_dgemv", "Illegal Order setting, %d\n", a1);
goto LABEL_20;
}
RowMajorStrg = 1;
switch ( a2 )
{
case 'o':
v18[0] = 84;
goto LABEL_16;
case 'p':
v18[0] = 78;
goto LABEL_16;
case 'q':
v18[0] = 78;
LABEL_16:
result = dgemv_(v18, &v16, v17, &v15, a5, &v14, a9, &a10, &v13, a11, &a12);
goto LABEL_20;
}
LABEL_14:
result = cblas_xerbla(2LL, "cblas_dgemv", "Illegal TransA setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
switch ( a2 )
{
case 'o':
v18[0] = 78;
break;
case 'p':
v18[0] = 84;
break;
case 'q':
v18[0] = 67;
break;
default:
goto LABEL_14;
}
result = dgemv_(v18, v17, &v16, &v15, a5, &v14, a9, &a10, &v13, a11, &a12);
LABEL_20:
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}

original_code:
void cblas_dgemv(const enum CBLAS_ORDER order,
                 const enum CBLAS_TRANSPOSE TransA, const int M, const int N,
                 const double alpha, const double *A, const int lda,
                 const double *X, const int incX, const double beta,
                 double *Y, const int incY)
{
   char TA;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      if (TransA == CblasNoTrans) TA = 'N';
      else if (TransA == CblasTrans) TA = 'T';
      else if (TransA == CblasConjTrans) TA = 'C';
      else
      {
         cblas_xerbla(2, "cblas_dgemv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      dgemv_(&TA, &M, &N, &alpha, A, &lda, X, &incX,
                &beta, Y, &incY);
   }
   else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (TransA == CblasNoTrans) TA = 'T';
      else if (TransA == CblasTrans) TA = 'N';
      else if (TransA == CblasConjTrans) TA = 'N';
      else
      {
         cblas_xerbla(2, "cblas_dgemv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      dgemv_(&TA, &N, &M, &alpha, A, &lda, X,
                &incX, &beta, Y, &incY);
   }
   else cblas_xerbla(1, "cblas_dgemv", "Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

canonical_original_code:
void cblas_dgemv(enum CBLAS_ORDER order, enum CBLAS_TRANSPOSE TransA, int M, int N, double alpha, double *A, int lda, double *X, int incX, double beta, double *Y, int incY)
{
   char TA;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      if (TransA == CblasNoTrans) TA = 'N';
      else if (TransA == CblasTrans) TA = 'T';
      else if (TransA == CblasConjTrans) TA = 'C';
      else
      {
         cblas_xerbla(2, "cblas_dgemv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      dgemv_(&TA, &M, &N, &alpha, A, &lda, X, &incX,
                &beta, Y, &incY);
   }
   else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (TransA == CblasNoTrans) TA = 'T';
      else if (TransA == CblasTrans) TA = 'N';
      else if (TransA == CblasConjTrans) TA = 'N';
      else
      {
         cblas_xerbla(2, "cblas_dgemv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      dgemv_(&TA, &N, &M, &alpha, A, &lda, X,
                &incX, &beta, Y, &incY);
   }
   else cblas_xerbla(1, "cblas_dgemv", "Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

variable_types: enum CBLAS_ORDER { CblasRowMajor=101, CblasColMajor=102 }

variable_types: M int

variable_types: N int

variable_types: alpha double

variable_types:
A
double *

variable_types: lda int

variable_types:
X
double *

variable_types: beta double

variable_types:
Y
double *

variable_types: TA char

user_defined_types: enum CBLAS_TRANSPOSE { CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113 }


decompiled_code:
__int64 __fastcall cblas_dgbmv(unsigned int a1, unsigned int a2, int a3, int a4, int a5, int a6, double a7, double a8, __int64 a9, char a10, __int64 a11, char a12, __int64 a13, char a14)
{
__int64 result; // rax
double v15; // [rsp+0h] [rbp-38h] BYREF
double v16; // [rsp+8h] [rbp-30h] BYREF
int v17; // [rsp+10h] [rbp-28h] BYREF
int v18; // [rsp+14h] [rbp-24h] BYREF
int v19; // [rsp+18h] [rbp-20h] BYREF
int v20[4]; // [rsp+1Ch] [rbp-1Ch] BYREF
char v21[9]; // [rsp+2Fh] [rbp-9h] BYREF

v20[0] = a3;
v19 = a4;
v18 = a5;
v17 = a6;
v16 = a7;
v15 = a8;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 != 102 )
{
if ( a1 != 101 )
{
result = cblas_xerbla(1LL, "cblas_dgbmv", "Illegal Order setting, %d\n", a1);
goto LABEL_20;
}
RowMajorStrg = 1;
switch ( a2 )
{
case 'o':
v21[0] = 84;
goto LABEL_16;
case 'p':
v21[0] = 78;
goto LABEL_16;
case 'q':
v21[0] = 78;
LABEL_16:
result = dgbmv_(v21, &v19, v20, &v17, &v18, &v16, a9, &a10, a11, &a12, &v15, a13, &a14);
goto LABEL_20;
}
LABEL_14:
result = cblas_xerbla(2LL, "cblas_dgbmv", "Illegal TransA setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
switch ( a2 )
{
case 'o':
v21[0] = 78;
break;
case 'p':
v21[0] = 84;
break;
case 'q':
v21[0] = 67;
break;
default:
goto LABEL_14;
}
result = dgbmv_(v21, v20, &v19, &v18, &v17, &v16, a9, &a10, a11, &a12, &v15, a13, &a14);
LABEL_20:
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func0(unsigned int a1, unsigned int a2, int a3, int a4, int a5, int a6, double a7, double a8, __int64 a9, char a10, __int64 a11, char a12, __int64 a13, char a14)
{
__int64 result; // rax
double v15; // [rsp+0h] [rbp-38h] BYREF
double v16; // [rsp+8h] [rbp-30h] BYREF
int v17; // [rsp+10h] [rbp-28h] BYREF
int v18; // [rsp+14h] [rbp-24h] BYREF
int v19; // [rsp+18h] [rbp-20h] BYREF
int v20[4]; // [rsp+1Ch] [rbp-1Ch] BYREF
char v21[9]; // [rsp+2Fh] [rbp-9h] BYREF

v20[0] = a3;
v19 = a4;
v18 = a5;
v17 = a6;
v16 = a7;
v15 = a8;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 != 102 )
{
if ( a1 != 101 )
{
result = cblas_xerbla(1LL, "cblas_dgbmv", "Illegal Order setting, %d\n", a1);
goto LABEL_20;
}
RowMajorStrg = 1;
switch ( a2 )
{
case 'o':
v21[0] = 84;
goto LABEL_16;
case 'p':
v21[0] = 78;
goto LABEL_16;
case 'q':
v21[0] = 78;
LABEL_16:
result = dgbmv_(v21, &v19, v20, &v17, &v18, &v16, a9, &a10, a11, &a12, &v15, a13, &a14);
goto LABEL_20;
}
LABEL_14:
result = cblas_xerbla(2LL, "cblas_dgbmv", "Illegal TransA setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
switch ( a2 )
{
case 'o':
v21[0] = 78;
break;
case 'p':
v21[0] = 84;
break;
case 'q':
v21[0] = 67;
break;
default:
goto LABEL_14;
}
result = dgbmv_(v21, v20, &v19, &v18, &v17, &v16, a9, &a10, a11, &a12, &v15, a13, &a14);
LABEL_20:
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}

original_code:
void cblas_dgbmv(const enum CBLAS_ORDER order,
                 const enum CBLAS_TRANSPOSE TransA, const int M, const int N,
                 const int KL, const int KU,
                 const double alpha, const double *A, const int lda,
                 const double *X, const int incX, const double beta,
                 double *Y, const int incY)
{
   char TA;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      if (TransA == CblasNoTrans) TA = 'N';
      else if (TransA == CblasTrans) TA = 'T';
      else if (TransA == CblasConjTrans) TA = 'C';
      else
      {
         cblas_xerbla(2, "cblas_dgbmv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      dgbmv_(&TA, &M, &N, &KL, &KU, &alpha,
                     A, &lda, X, &incX, &beta, Y, &incY);
   }
   else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (TransA == CblasNoTrans) TA = 'T';
      else if (TransA == CblasTrans) TA = 'N';
      else if (TransA == CblasConjTrans) TA = 'N';
      else
      {
         cblas_xerbla(2, "cblas_dgbmv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      dgbmv_(&TA, &N, &M, &KU, &KL, &alpha,
                     A ,&lda, X,&incX, &beta, Y, &incY);
   }
   else cblas_xerbla(1, "cblas_dgbmv", "Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
}

canonical_original_code:
void cblas_dgbmv(enum CBLAS_ORDER order, enum CBLAS_TRANSPOSE TransA, int M, int N, int KL, int KU, double alpha, double *A, int lda, double *X, int incX, double beta, double *Y, int incY)
{
   char TA;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      if (TransA == CblasNoTrans) TA = 'N';
      else if (TransA == CblasTrans) TA = 'T';
      else if (TransA == CblasConjTrans) TA = 'C';
      else
      {
         cblas_xerbla(2, "cblas_dgbmv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      dgbmv_(&TA, &M, &N, &KL, &KU, &alpha,
                     A, &lda, X, &incX, &beta, Y, &incY);
   }
   else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (TransA == CblasNoTrans) TA = 'T';
      else if (TransA == CblasTrans) TA = 'N';
      else if (TransA == CblasConjTrans) TA = 'N';
      else
      {
         cblas_xerbla(2, "cblas_dgbmv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      dgbmv_(&TA, &N, &M, &KU, &KL, &alpha,
                     A ,&lda, X,&incX, &beta, Y, &incY);
   }
   else cblas_xerbla(1, "cblas_dgbmv", "Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
}

variable_types: enum CBLAS_TRANSPOSE { CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113 }

variable_types: KL int

variable_types: KU int

user_defined_types: enum CBLAS_ORDER { CblasRowMajor=101, CblasColMajor=102 }


decompiled_code:
__int64 __fastcall cblas_zscal(int a1, __int64 a2, __int64 a3, int a4)
{
int v5; // [rsp+8h] [rbp-10h] BYREF
int v6[3]; // [rsp+Ch] [rbp-Ch] BYREF

v6[0] = a1;
v5 = a4;
return zscal_(v6, a2, a3, &v5);
}

canonical_decompiled_code:
__int64 __fastcall func0(int a1, __int64 a2, __int64 a3, int a4)
{
int v5; // [rsp+8h] [rbp-10h] BYREF
int v6[3]; // [rsp+Ch] [rbp-Ch] BYREF

v6[0] = a1;
v5 = a4;
return zscal_(v6, a2, a3, &v5);
}

original_code:
void cblas_zscal( const int N, const void *alpha, void *X,
                       const int incX)
{
   zscal_( &N, alpha, X, &incX);
}

canonical_original_code:
void cblas_zscal(int N, void *alpha, void *X, int incX)
{
   zscal_( &N, alpha, X, &incX);
}

variable_types:
alpha
void *

variable_types:
X
void *


decompiled_code:
void __fastcall cblas_chpr(unsigned int a1, unsigned int a2, int a3, _DWORD *a4, int a5, __int64 a6, float a7)
{
size_t v10; // r14
_DWORD *v11; // rax
_DWORD *v12; // r13
int v13; // ebx
_DWORD *v14; // rsi
int v15; // ecx
__int64 v16; // rcx
__int64 v17; // rbx
_DWORD *v18; // rdx
float v19; // [rsp+8h] [rbp-40h] BYREF
int v20[3]; // [rsp+Ch] [rbp-3Ch] BYREF
int v21; // [rsp+18h] [rbp-30h] BYREF
char v22[41]; // [rsp+1Fh] [rbp-29h] BYREF

v20[0] = a3;
v19 = a7;
v21 = a5;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 == 102 )
{
if ( a2 == 122 )
{
v22[0] = 76;
goto LABEL_7;
}
if ( a2 == 121 )
{
v22[0] = 85;
goto LABEL_7;
}
goto LABEL_12;
}
if ( a1 == 101 )
{
RowMajorStrg = 1;
if ( a2 == 121 )
{
v22[0] = 76;
LABEL_6:
if ( v20[0] > 0 )
{
v10 = 2LL * v20[0];
v11 = malloc(v10 * 4);
v12 = v11;
if ( a5 <= 0 )
{
v13 = -2 * a5;
v14 = v11 - 2;
v11 = &v11[v10 - 2];
v15 = -2;
}
else
{
v13 = 2 * a5;
v14 = &v11[v10];
v15 = 2;
}
v16 = 4LL * v15;
v17 = 4LL * v13;
v18 = a4;
do
{
*v11 = *v18;
v11[1] = v18[1] ^ LC2;
v11 = (_DWORD *)((char *)v11 + v16);
v18 = (_DWORD *)((char *)v18 + v17);
}
while ( v11 != v14 );
v21 = 1;
chpr_(v22, v20, &v19, v12, &v21, a6);
if ( a4 != v12 )
free(v12);
goto LABEL_21;
}
LABEL_7:
chpr_(v22, v20, &v19, a4, &v21, a6);
LABEL_21:
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return;
}
if ( a2 == 122 )
{
v22[0] = 85;
goto LABEL_6;
}
LABEL_12:
cblas_xerbla(2LL, "cblas_chpr", "Illegal Uplo setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return;
}
cblas_xerbla(1LL, "cblas_chpr", "Illegal Order setting, %d\n", a1);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
}

canonical_decompiled_code:
void __fastcall func0(unsigned int a1, unsigned int a2, int a3, _DWORD *a4, int a5, __int64 a6, float a7)
{
size_t v10; // r14
_DWORD *v11; // rax
_DWORD *v12; // r13
int v13; // ebx
_DWORD *v14; // rsi
int v15; // ecx
__int64 v16; // rcx
__int64 v17; // rbx
_DWORD *v18; // rdx
float v19; // [rsp+8h] [rbp-40h] BYREF
int v20[3]; // [rsp+Ch] [rbp-3Ch] BYREF
int v21; // [rsp+18h] [rbp-30h] BYREF
char v22[41]; // [rsp+1Fh] [rbp-29h] BYREF

v20[0] = a3;
v19 = a7;
v21 = a5;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 == 102 )
{
if ( a2 == 122 )
{
v22[0] = 76;
goto LABEL_7;
}
if ( a2 == 121 )
{
v22[0] = 85;
goto LABEL_7;
}
goto LABEL_12;
}
if ( a1 == 101 )
{
RowMajorStrg = 1;
if ( a2 == 121 )
{
v22[0] = 76;
LABEL_6:
if ( v20[0] > 0 )
{
v10 = 2LL * v20[0];
v11 = malloc(v10 * 4);
v12 = v11;
if ( a5 <= 0 )
{
v13 = -2 * a5;
v14 = v11 - 2;
v11 = &v11[v10 - 2];
v15 = -2;
}
else
{
v13 = 2 * a5;
v14 = &v11[v10];
v15 = 2;
}
v16 = 4LL * v15;
v17 = 4LL * v13;
v18 = a4;
do
{
*v11 = *v18;
v11[1] = v18[1] ^ LC2;
v11 = (_DWORD *)((char *)v11 + v16);
v18 = (_DWORD *)((char *)v18 + v17);
}
while ( v11 != v14 );
v21 = 1;
chpr_(v22, v20, &v19, v12, &v21, a6);
if ( a4 != v12 )
free(v12);
goto LABEL_21;
}
LABEL_7:
chpr_(v22, v20, &v19, a4, &v21, a6);
LABEL_21:
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return;
}
if ( a2 == 122 )
{
v22[0] = 85;
goto LABEL_6;
}
LABEL_12:
cblas_xerbla(2LL, "cblas_chpr", "Illegal Uplo setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return;
}
cblas_xerbla(1LL, "cblas_chpr", "Illegal Order setting, %d\n", a1);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
}

original_code:
void cblas_chpr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
                const int N, const float alpha, const void *X,
                const int incX, void *A)
{
   char UL;
   int n, i, tincx, incx=incX;
   float *x=(float *)X, *xx=(float *)X, *tx, *st;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      if (Uplo == CblasLower) UL = 'L';
      else if (Uplo == CblasUpper) UL = 'U';
      else
      {
         cblas_xerbla(2, "cblas_chpr","Illegal Uplo setting, %d\n",Uplo );
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      chpr_(&UL, &N, &alpha, X, &incx, A);
   } else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (Uplo == CblasUpper) UL = 'L';
      else if (Uplo == CblasLower) UL = 'U';
      else
      {
         cblas_xerbla(2, "cblas_chpr","Illegal Uplo setting, %d\n", Uplo);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if (N > 0)
      {
         n = N << 1;
         x = malloc(n*sizeof(float));
         tx = x;
         if( incX > 0 ) {
            i = incX << 1;
            tincx = 2;
            st= x+n;
         } else {
            i = incX *(-2);
            tincx = -2;
            st = x-2;
            x +=(n-2);
         }
         do
         {
            *x = *xx;
            x[1] = -xx[1];
            x += tincx ;
            xx += i;
         }
         while (x != st);
         x=tx;
            incx = 1;
      }
      else x = (float *) X;
      chpr_(&UL, &N, &alpha, x, &incx, A);
   } else
   {
      cblas_xerbla(1, "cblas_chpr","Illegal Order setting, %d\n", order);
      CBLAS_CallFromC = 0;
      RowMajorStrg = 0;
      return;
   }
   if(X!=x)
     free(x);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

canonical_original_code:
void cblas_chpr(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, int N, float alpha, void *X, int incX, void *A)
{
   char UL;
   int n; int i; int tincx; int incx = incX;
   float *x = (float *)X; float *xx = (float *)X; float *tx; float *st;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      if (Uplo == CblasLower) UL = 'L';
      else if (Uplo == CblasUpper) UL = 'U';
      else
      {
         cblas_xerbla(2, "cblas_chpr","Illegal Uplo setting, %d\n",Uplo );
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      chpr_(&UL, &N, &alpha, X, &incx, A);
   } else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (Uplo == CblasUpper) UL = 'L';
      else if (Uplo == CblasLower) UL = 'U';
      else
      {
         cblas_xerbla(2, "cblas_chpr","Illegal Uplo setting, %d\n", Uplo);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if (N > 0)
      {
         n = N << 1;
         x = malloc(n*sizeof(float));
         tx = x;
         if( incX > 0 ) {
            i = incX << 1;
            tincx = 2;
            st= x+n;
         } else {
            i = incX *(-2);
            tincx = -2;
            st = x-2;
            x +=(n-2);
         }
         do
         {
            *x = *xx;
            x[1] = -xx[1];
            x += tincx ;
            xx += i;
         }
         while (x != st);
         x=tx;
            incx = 1;
      }
      else x = (float *) X;
      chpr_(&UL, &N, &alpha, x, &incx, A);
   } else
   {
      cblas_xerbla(1, "cblas_chpr","Illegal Order setting, %d\n", order);
      CBLAS_CallFromC = 0;
      RowMajorStrg = 0;
      return;
   }
   if(X!=x)
     free(x);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

variable_types: enum CBLAS_UPLO { CblasUpper=121, CblasLower=122 }

variable_types: alpha float

variable_types: incX int

variable_types:
A
void *

variable_types: UL char

variable_types: n int

variable_types: i int

variable_types: tincx int

variable_types: incx int

variable_types:
x
float *

variable_types:
xx
float *

variable_types:
tx
float *

variable_types:
st
float *

variable_types: RowMajorStrg int


decompiled_code:
__int64 __fastcall cblas_dtpmv(unsigned int a1, unsigned int a2, unsigned int a3, __int64 a4, int a5, __int64 a6, __int64 a7, char a8)
{
__int64 result; // rax
int v9[4]; // [rsp+Ch] [rbp-1Ch] BYREF
char v10; // [rsp+1Dh] [rbp-Bh] BYREF
char v11; // [rsp+1Eh] [rbp-Ah] BYREF
char v12[9]; // [rsp+1Fh] [rbp-9h] BYREF

v9[0] = a5;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 != 102 )
{
if ( a1 != 101 )
{
result = cblas_xerbla(1LL, "cblas_dtpmv", "Illegal Order setting, %d\n", a1);
goto LABEL_39;
}
RowMajorStrg = 1;
if ( a2 == 121 )
{
v11 = 76;
LABEL_6:
switch ( a3 )
{
case 'o':
v12[0] = 84;
break;
case 'p':
v12[0] = 78;
break;
case 'q':
v12[0] = 78;
break;
default:
LABEL_25:
result = cblas_xerbla(3LL, "cblas_dtpmv", "Illegal TransA setting, %d\n", a3);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
if ( (_DWORD)a4 == 132 )
{
v10 = 85;
goto LABEL_23;
}
if ( (_DWORD)a4 == 131 )
{
v10 = 78;
goto LABEL_23;
}
LABEL_27:
result = cblas_xerbla(4LL, "cblas_dtpmv", "Illegal Diag setting, %d\n", a4);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
if ( a2 == 122 )
{
v11 = 85;
goto LABEL_6;
}
LABEL_18:
result = cblas_xerbla(2LL, "cblas_dtpmv", "Illegal Uplo setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
if ( a2 == 121 )
{
v11 = 85;
}
else
{
if ( a2 != 122 )
goto LABEL_18;
v11 = 76;
}
switch ( a3 )
{
case 'o':
v12[0] = 78;
break;
case 'p':
v12[0] = 84;
break;
case 'q':
v12[0] = 67;
break;
default:
goto LABEL_25;
}
if ( (_DWORD)a4 == 132 )
{
v10 = 85;
}
else
{
if ( (_DWORD)a4 != 131 )
goto LABEL_27;
v10 = 78;
}
LABEL_23:
result = dtpmv_(&v11, v12, &v10, v9, a6, a7, &a8);
LABEL_39:
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func0(unsigned int a1, unsigned int a2, unsigned int a3, __int64 a4, int a5, __int64 a6, __int64 a7, char a8)
{
__int64 result; // rax
int v9[4]; // [rsp+Ch] [rbp-1Ch] BYREF
char v10; // [rsp+1Dh] [rbp-Bh] BYREF
char v11; // [rsp+1Eh] [rbp-Ah] BYREF
char v12[9]; // [rsp+1Fh] [rbp-9h] BYREF

v9[0] = a5;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 != 102 )
{
if ( a1 != 101 )
{
result = cblas_xerbla(1LL, "cblas_dtpmv", "Illegal Order setting, %d\n", a1);
goto LABEL_39;
}
RowMajorStrg = 1;
if ( a2 == 121 )
{
v11 = 76;
LABEL_6:
switch ( a3 )
{
case 'o':
v12[0] = 84;
break;
case 'p':
v12[0] = 78;
break;
case 'q':
v12[0] = 78;
break;
default:
LABEL_25:
result = cblas_xerbla(3LL, "cblas_dtpmv", "Illegal TransA setting, %d\n", a3);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
if ( (_DWORD)a4 == 132 )
{
v10 = 85;
goto LABEL_23;
}
if ( (_DWORD)a4 == 131 )
{
v10 = 78;
goto LABEL_23;
}
LABEL_27:
result = cblas_xerbla(4LL, "cblas_dtpmv", "Illegal Diag setting, %d\n", a4);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
if ( a2 == 122 )
{
v11 = 85;
goto LABEL_6;
}
LABEL_18:
result = cblas_xerbla(2LL, "cblas_dtpmv", "Illegal Uplo setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
if ( a2 == 121 )
{
v11 = 85;
}
else
{
if ( a2 != 122 )
goto LABEL_18;
v11 = 76;
}
switch ( a3 )
{
case 'o':
v12[0] = 78;
break;
case 'p':
v12[0] = 84;
break;
case 'q':
v12[0] = 67;
break;
default:
goto LABEL_25;
}
if ( (_DWORD)a4 == 132 )
{
v10 = 85;
}
else
{
if ( (_DWORD)a4 != 131 )
goto LABEL_27;
v10 = 78;
}
LABEL_23:
result = dtpmv_(&v11, v12, &v10, v9, a6, a7, &a8);
LABEL_39:
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}

original_code:
void cblas_dtpmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
                 const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,
                 const int N, const double *Ap, double *X, const int incX)
{
   char TA;
   char UL;
   char DI;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      if (Uplo == CblasUpper) UL = 'U';
      else if (Uplo == CblasLower) UL = 'L';
      else
      {
         cblas_xerbla(2, "cblas_dtpmv","Illegal Uplo setting, %d\n", Uplo);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if (TransA == CblasNoTrans) TA = 'N';
      else if (TransA == CblasTrans) TA = 'T';
      else if (TransA == CblasConjTrans) TA = 'C';
      else
      {
         cblas_xerbla(3, "cblas_dtpmv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if (Diag == CblasUnit) DI = 'U';
      else if (Diag == CblasNonUnit) DI = 'N';
      else
      {
         cblas_xerbla(4, "cblas_dtpmv","Illegal Diag setting, %d\n", Diag);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      dtpmv_( &UL, &TA, &DI, &N, Ap, X, &incX);
   }
   else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (Uplo == CblasUpper) UL = 'L';
      else if (Uplo == CblasLower) UL = 'U';
      else
      {
         cblas_xerbla(2, "cblas_dtpmv","Illegal Uplo setting, %d\n", Uplo);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if (TransA == CblasNoTrans) TA = 'T';
      else if (TransA == CblasTrans) TA = 'N';
      else if (TransA == CblasConjTrans) TA = 'N';
      else
      {
         cblas_xerbla(3, "cblas_dtpmv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if (Diag == CblasUnit) DI = 'U';
      else if (Diag == CblasNonUnit) DI = 'N';
      else
      {
         cblas_xerbla(4, "cblas_dtpmv","Illegal Diag setting, %d\n", Diag);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      dtpmv_( &UL, &TA, &DI, &N, Ap, X,&incX);
   }
   else cblas_xerbla(1, "cblas_dtpmv", "Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

canonical_original_code:
void cblas_dtpmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N, double *Ap, double *X, int incX)
{
   char TA;
   char UL;
   char DI;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      if (Uplo == CblasUpper) UL = 'U';
      else if (Uplo == CblasLower) UL = 'L';
      else
      {
         cblas_xerbla(2, "cblas_dtpmv","Illegal Uplo setting, %d\n", Uplo);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if (TransA == CblasNoTrans) TA = 'N';
      else if (TransA == CblasTrans) TA = 'T';
      else if (TransA == CblasConjTrans) TA = 'C';
      else
      {
         cblas_xerbla(3, "cblas_dtpmv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if (Diag == CblasUnit) DI = 'U';
      else if (Diag == CblasNonUnit) DI = 'N';
      else
      {
         cblas_xerbla(4, "cblas_dtpmv","Illegal Diag setting, %d\n", Diag);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      dtpmv_( &UL, &TA, &DI, &N, Ap, X, &incX);
   }
   else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (Uplo == CblasUpper) UL = 'L';
      else if (Uplo == CblasLower) UL = 'U';
      else
      {
         cblas_xerbla(2, "cblas_dtpmv","Illegal Uplo setting, %d\n", Uplo);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if (TransA == CblasNoTrans) TA = 'T';
      else if (TransA == CblasTrans) TA = 'N';
      else if (TransA == CblasConjTrans) TA = 'N';
      else
      {
         cblas_xerbla(3, "cblas_dtpmv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if (Diag == CblasUnit) DI = 'U';
      else if (Diag == CblasNonUnit) DI = 'N';
      else
      {
         cblas_xerbla(4, "cblas_dtpmv","Illegal Diag setting, %d\n", Diag);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      dtpmv_( &UL, &TA, &DI, &N, Ap, X,&incX);
   }
   else cblas_xerbla(1, "cblas_dtpmv", "Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

variable_types: enum CBLAS_ORDER { CblasRowMajor=101, CblasColMajor=102 }

variable_types: enum CBLAS_TRANSPOSE { CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113 }

variable_types: enum CBLAS_DIAG { CblasNonUnit=131, CblasUnit=132 }

variable_types: N int

variable_types:
Ap
double *

variable_types:
X
double *

variable_types: TA char

variable_types: DI char

user_defined_types: enum CBLAS_UPLO { CblasUpper=121, CblasLower=122 }


decompiled_code:
void __fastcall cblas_cher(unsigned int a1, unsigned int a2, int a3, _DWORD *a4, int a5, __int64 a6, float a7, char a8)
{
size_t v11; // r14
_DWORD *v12; // rax
_DWORD *v13; // r13
int v14; // ebx
_DWORD *v15; // rsi
int v16; // ecx
__int64 v17; // rcx
__int64 v18; // rbx
_DWORD *v19; // rdx
float v20; // [rsp+8h] [rbp-40h] BYREF
int v21[3]; // [rsp+Ch] [rbp-3Ch] BYREF
int v22; // [rsp+18h] [rbp-30h] BYREF
char v23[41]; // [rsp+1Fh] [rbp-29h] BYREF

v21[0] = a3;
v20 = a7;
v22 = a5;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 == 102 )
{
if ( a2 == 122 )
{
v23[0] = 76;
goto LABEL_7;
}
if ( a2 == 121 )
{
v23[0] = 85;
goto LABEL_7;
}
goto LABEL_12;
}
if ( a1 == 101 )
{
RowMajorStrg = 1;
if ( a2 == 121 )
{
v23[0] = 76;
LABEL_6:
if ( v21[0] > 0 )
{
v11 = 2LL * v21[0];
v12 = malloc(v11 * 4);
v13 = v12;
if ( a5 <= 0 )
{
v14 = -2 * a5;
v15 = v12 - 2;
v12 = &v12[v11 - 2];
v16 = -2;
}
else
{
v14 = 2 * a5;
v15 = &v12[v11];
v16 = 2;
}
v17 = 4LL * v16;
v18 = 4LL * v14;
v19 = a4;
do
{
*v12 = *v19;
v12[1] = v19[1] ^ LC2;
v12 = (_DWORD *)((char *)v12 + v17);
v19 = (_DWORD *)((char *)v19 + v18);
}
while ( v12 != v15 );
v22 = 1;
cher_(v23, v21, &v20, v13, &v22, a6, &a8);
if ( a4 != v13 )
free(v13);
goto LABEL_21;
}
LABEL_7:
cher_(v23, v21, &v20, a4, &v22, a6, &a8);
LABEL_21:
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return;
}
if ( a2 == 122 )
{
v23[0] = 85;
goto LABEL_6;
}
LABEL_12:
cblas_xerbla(2LL, "cblas_cher", "Illegal Uplo setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return;
}
cblas_xerbla(1LL, "cblas_cher", "Illegal Order setting, %d\n", a1);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
}

canonical_decompiled_code:
void __fastcall func0(unsigned int a1, unsigned int a2, int a3, _DWORD *a4, int a5, __int64 a6, float a7, char a8)
{
size_t v11; // r14
_DWORD *v12; // rax
_DWORD *v13; // r13
int v14; // ebx
_DWORD *v15; // rsi
int v16; // ecx
__int64 v17; // rcx
__int64 v18; // rbx
_DWORD *v19; // rdx
float v20; // [rsp+8h] [rbp-40h] BYREF
int v21[3]; // [rsp+Ch] [rbp-3Ch] BYREF
int v22; // [rsp+18h] [rbp-30h] BYREF
char v23[41]; // [rsp+1Fh] [rbp-29h] BYREF

v21[0] = a3;
v20 = a7;
v22 = a5;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 == 102 )
{
if ( a2 == 122 )
{
v23[0] = 76;
goto LABEL_7;
}
if ( a2 == 121 )
{
v23[0] = 85;
goto LABEL_7;
}
goto LABEL_12;
}
if ( a1 == 101 )
{
RowMajorStrg = 1;
if ( a2 == 121 )
{
v23[0] = 76;
LABEL_6:
if ( v21[0] > 0 )
{
v11 = 2LL * v21[0];
v12 = malloc(v11 * 4);
v13 = v12;
if ( a5 <= 0 )
{
v14 = -2 * a5;
v15 = v12 - 2;
v12 = &v12[v11 - 2];
v16 = -2;
}
else
{
v14 = 2 * a5;
v15 = &v12[v11];
v16 = 2;
}
v17 = 4LL * v16;
v18 = 4LL * v14;
v19 = a4;
do
{
*v12 = *v19;
v12[1] = v19[1] ^ LC2;
v12 = (_DWORD *)((char *)v12 + v17);
v19 = (_DWORD *)((char *)v19 + v18);
}
while ( v12 != v15 );
v22 = 1;
cher_(v23, v21, &v20, v13, &v22, a6, &a8);
if ( a4 != v13 )
free(v13);
goto LABEL_21;
}
LABEL_7:
cher_(v23, v21, &v20, a4, &v22, a6, &a8);
LABEL_21:
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return;
}
if ( a2 == 122 )
{
v23[0] = 85;
goto LABEL_6;
}
LABEL_12:
cblas_xerbla(2LL, "cblas_cher", "Illegal Uplo setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return;
}
cblas_xerbla(1LL, "cblas_cher", "Illegal Order setting, %d\n", a1);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
}

original_code:
void cblas_cher(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
                const int N, const float alpha, const void *X, const int incX
                ,void *A, const int lda)
{
   char UL;
   int n, i, tincx, incx=incX;
   float *x=(float *)X, *xx=(float *)X, *tx, *st;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      if (Uplo == CblasLower) UL = 'L';
      else if (Uplo == CblasUpper) UL = 'U';
      else
      {
         cblas_xerbla(2, "cblas_cher","Illegal Uplo setting, %d\n",Uplo );
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      cher_(&UL, &N, &alpha, X, &incx, A, &lda);
   } else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (Uplo == CblasUpper) UL = 'L';
      else if (Uplo == CblasLower) UL = 'U';
      else
      {
         cblas_xerbla(2, "cblas_cher","Illegal Uplo setting, %d\n", Uplo);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if (N > 0)
      {
         n = N << 1;
         x = malloc(n*sizeof(float));
         tx = x;
         if( incX > 0 ) {
            i = incX << 1 ;
            tincx = 2;
            st= x+n;
         } else {
            i = incX *(-2);
            tincx = -2;
            st = x-2;
            x +=(n-2);
         }
         do
         {
            *x = *xx;
            x[1] = -xx[1];
            x += tincx ;
            xx += i;
         }
         while (x != st);
         x=tx;
           incx = 1;
      }
      else x = (float *) X;
      cher_(&UL, &N, &alpha, x, &incx, A, &lda);
   } else
   {
      cblas_xerbla(1, "cblas_cher","Illegal Order setting, %d\n", order);
      CBLAS_CallFromC = 0;
      RowMajorStrg = 0;
      return;
   }
   if(X!=x)
      free(x);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

canonical_original_code:
void cblas_cher(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, int N, float alpha, void *X, int incX, void *A, int lda)
{
   char UL;
   int n; int i; int tincx; int incx = incX;
   float *x = (float *)X; float *xx = (float *)X; float *tx; float *st;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      if (Uplo == CblasLower) UL = 'L';
      else if (Uplo == CblasUpper) UL = 'U';
      else
      {
         cblas_xerbla(2, "cblas_cher","Illegal Uplo setting, %d\n",Uplo );
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      cher_(&UL, &N, &alpha, X, &incx, A, &lda);
   } else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (Uplo == CblasUpper) UL = 'L';
      else if (Uplo == CblasLower) UL = 'U';
      else
      {
         cblas_xerbla(2, "cblas_cher","Illegal Uplo setting, %d\n", Uplo);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if (N > 0)
      {
         n = N << 1;
         x = malloc(n*sizeof(float));
         tx = x;
         if( incX > 0 ) {
            i = incX << 1 ;
            tincx = 2;
            st= x+n;
         } else {
            i = incX *(-2);
            tincx = -2;
            st = x-2;
            x +=(n-2);
         }
         do
         {
            *x = *xx;
            x[1] = -xx[1];
            x += tincx ;
            xx += i;
         }
         while (x != st);
         x=tx;
           incx = 1;
      }
      else x = (float *) X;
      cher_(&UL, &N, &alpha, x, &incx, A, &lda);
   } else
   {
      cblas_xerbla(1, "cblas_cher","Illegal Order setting, %d\n", order);
      CBLAS_CallFromC = 0;
      RowMajorStrg = 0;
      return;
   }
   if(X!=x)
      free(x);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

variable_types: enum CBLAS_UPLO { CblasUpper=121, CblasLower=122 }

variable_types: alpha float

variable_types:
X
void *

variable_types: incX int

variable_types:
A
void *

variable_types: lda int

variable_types: UL char

variable_types: n int


decompiled_code:
__int64 __fastcall cblas_dscal(int a1, __int64 a2, int a3, double a4)
{
double v5; // [rsp+0h] [rbp-18h] BYREF
int v6; // [rsp+8h] [rbp-10h] BYREF
int v7[3]; // [rsp+Ch] [rbp-Ch] BYREF

v7[0] = a1;
v5 = a4;
v6 = a3;
return dscal_(v7, &v5, a2, &v6);
}

canonical_decompiled_code:
__int64 __fastcall func0(int a1, __int64 a2, int a3, double a4)
{
double v5; // [rsp+0h] [rbp-18h] BYREF
int v6; // [rsp+8h] [rbp-10h] BYREF
int v7[3]; // [rsp+Ch] [rbp-Ch] BYREF

v7[0] = a1;
v5 = a4;
v6 = a3;
return dscal_(v7, &v5, a2, &v6);
}

original_code:
void cblas_dscal( const int N, const double alpha, double *X,
                       const int incX)
{
   dscal_( &N, &alpha, X, &incX);
}

canonical_original_code:
void cblas_dscal(int N, double alpha, double *X, int incX)
{
   dscal_( &N, &alpha, X, &incX);
}

variable_types: alpha double


decompiled_code:
__int64 __fastcall cblas_ssyr2(unsigned int a1, unsigned int a2, int a3, __int64 a4, int a5, float a6)
{
__int64 result; // rax
int v7; // [rsp+4h] [rbp-24h] BYREF
float v8; // [rsp+8h] [rbp-20h] BYREF
int v9[4]; // [rsp+Ch] [rbp-1Ch] BYREF
char v10[9]; // [rsp+1Fh] [rbp-9h] BYREF

v9[0] = a3;
v8 = a6;
v7 = a5;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 == 102 )
{
if ( a2 == 122 )
{
v10[0] = 76;
goto LABEL_6;
}
if ( a2 == 121 )
{
v10[0] = 85;
goto LABEL_6;
}
LABEL_11:
result = cblas_xerbla(2LL, "cblas_ssyr2", "Illegal Uplo setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
if ( a1 != 101 )
{
result = cblas_xerbla(1LL, "cblas_ssyr2", "Illegal Order setting, %d\n", a1);
goto LABEL_15;
}
RowMajorStrg = 1;
if ( a2 == 122 )
{
v10[0] = 85;
goto LABEL_6;
}
if ( a2 != 121 )
goto LABEL_11;
v10[0] = 76;
LABEL_6:
result = ssyr2_(v10, v9, &v8, a4, &v7);
LABEL_15:
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func0(unsigned int a1, unsigned int a2, int a3, __int64 a4, int a5, float a6)
{
__int64 result; // rax
int v7; // [rsp+4h] [rbp-24h] BYREF
float v8; // [rsp+8h] [rbp-20h] BYREF
int v9[4]; // [rsp+Ch] [rbp-1Ch] BYREF
char v10[9]; // [rsp+1Fh] [rbp-9h] BYREF

v9[0] = a3;
v8 = a6;
v7 = a5;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 == 102 )
{
if ( a2 == 122 )
{
v10[0] = 76;
goto LABEL_6;
}
if ( a2 == 121 )
{
v10[0] = 85;
goto LABEL_6;
}
LABEL_11:
result = cblas_xerbla(2LL, "cblas_ssyr2", "Illegal Uplo setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
if ( a1 != 101 )
{
result = cblas_xerbla(1LL, "cblas_ssyr2", "Illegal Order setting, %d\n", a1);
goto LABEL_15;
}
RowMajorStrg = 1;
if ( a2 == 122 )
{
v10[0] = 85;
goto LABEL_6;
}
if ( a2 != 121 )
goto LABEL_11;
v10[0] = 76;
LABEL_6:
result = ssyr2_(v10, v9, &v8, a4, &v7);
LABEL_15:
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}

original_code:
void cblas_ssyr2(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
                const int N, const float alpha, const float *X,
                const int incX, const float *Y, const int incY, float *A,
                const int lda)
{
   char UL;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      if (Uplo == CblasLower) UL = 'L';
      else if (Uplo == CblasUpper) UL = 'U';
      else
      {
         cblas_xerbla(2, "cblas_ssyr2","Illegal Uplo setting, %d\n",Uplo );
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      ssyr2_(&UL, &N, &alpha, X, &incX, Y, &incY, A,
                    &lda);
   } else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (Uplo == CblasLower) UL = 'U';
      else if (Uplo == CblasUpper) UL = 'L';
      else
      {
         cblas_xerbla(2, "cblas_ssyr2","Illegal Uplo setting, %d\n",Uplo );
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      ssyr2_(&UL, &N, &alpha, X, &incX, Y, &incY, A,
                    &lda);
   } else cblas_xerbla(1, "cblas_ssyr2", "Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

canonical_original_code:
void cblas_ssyr2(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, int N, float alpha, float *X, int incX, float *Y, int incY, float *A, int lda)
{
   char UL;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      if (Uplo == CblasLower) UL = 'L';
      else if (Uplo == CblasUpper) UL = 'U';
      else
      {
         cblas_xerbla(2, "cblas_ssyr2","Illegal Uplo setting, %d\n",Uplo );
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      ssyr2_(&UL, &N, &alpha, X, &incX, Y, &incY, A,
                    &lda);
   } else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (Uplo == CblasLower) UL = 'U';
      else if (Uplo == CblasUpper) UL = 'L';
      else
      {
         cblas_xerbla(2, "cblas_ssyr2","Illegal Uplo setting, %d\n",Uplo );
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      ssyr2_(&UL, &N, &alpha, X, &incX, Y, &incY, A,
                    &lda);
   } else cblas_xerbla(1, "cblas_ssyr2", "Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

variable_types: enum CBLAS_ORDER { CblasRowMajor=101, CblasColMajor=102 }

variable_types:
X
float *

variable_types:
Y
float *

variable_types: incY int

variable_types:
A
float *

variable_types: RowMajorStrg int


original_code:
void cblas_cgerc(const enum CBLAS_ORDER order, const int M, const int N,
                 const void *alpha, const void *X, const int incX,
                 const void *Y, const int incY, void *A, const int lda)
{
   int n, i, tincy, incy=incY;
   float *y=(float *)Y, *yy=(float *)Y, *ty, *st;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      cgerc_( &M, &N, alpha, X, &incX, Y, &incy, A,
                      &lda);
   } else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (N > 0)
      {
         n = N << 1;
         y = malloc(n*sizeof(float));
         ty = y;
         if( incY > 0 ) {
            i = incY << 1;
            tincy = 2;
            st= y+n;
         } else {
            i = incY *(-2);
            tincy = -2;
            st = y-2;
            y +=(n-2);
         }
         do
         {
            *y = *yy;
            y[1] = -yy[1];
            y += tincy ;
            yy += i;
         }
         while (y != st);
         y = ty;
            incy = 1;
      }
      else y = (float *) Y;
      cgeru_( &N, &M, alpha, y, &incy, X, &incX, A,
                      &lda);
      if(Y!=y)
         free(y);
   } else cblas_xerbla(1, "cblas_cgerc", "Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

canonical_original_code:
void cblas_cgerc(enum CBLAS_ORDER order, int M, int N, void *alpha, void *X, int incX, void *Y, int incY, void *A, int lda)
{
   int n; int i; int tincy; int incy = incY;
   float *y = (float *)Y; float *yy = (float *)Y; float *ty; float *st;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      cgerc_( &M, &N, alpha, X, &incX, Y, &incy, A,
                      &lda);
   } else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (N > 0)
      {
         n = N << 1;
         y = malloc(n*sizeof(float));
         ty = y;
         if( incY > 0 ) {
            i = incY << 1;
            tincy = 2;
            st= y+n;
         } else {
            i = incY *(-2);
            tincy = -2;
            st = y-2;
            y +=(n-2);
         }
         do
         {
            *y = *yy;
            y[1] = -yy[1];
            y += tincy ;
            yy += i;
         }
         while (y != st);
         y = ty;
            incy = 1;
      }
      else y = (float *) Y;
      cgeru_( &N, &M, alpha, y, &incy, X, &incX, A,
                      &lda);
      if(Y!=y)
         free(y);
   } else cblas_xerbla(1, "cblas_cgerc", "Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

variable_types: M int

variable_types: N int

variable_types:
alpha
void *

variable_types:
Y
void *

variable_types: i int

variable_types: tincy int

variable_types: incy int

variable_types:
y
float *

variable_types:
yy
float *

variable_types:
ty
float *

variable_types:
st
float *


decompiled_code:
__int64 __fastcall cblas_zgeru(unsigned int a1, int a2, int a3, __int64 a4, __int64 a5, int a6, __int64 a7, char a8, __int64 a9, char a10)
{
__int64 result; // rax
int v11; // [rsp+4h] [rbp-14h] BYREF
int v12; // [rsp+8h] [rbp-10h] BYREF
int v13[3]; // [rsp+Ch] [rbp-Ch] BYREF

v13[0] = a2;
v12 = a3;
v11 = a6;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 == 102 )
{
result = zgeru_(v13, &v12, a4, a5, &v11, a7, &a8, a9, &a10);
}
else if ( a1 == 101 )
{
RowMajorStrg = 1;
result = zgeru_(&v12, v13, a4, a7, &a8, a5, &v11, a9, &a10);
}
else
{
result = cblas_xerbla(1LL, "cblas_zgeru", "Illegal Order setting, %d\n", a1);
}
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func0(unsigned int a1, int a2, int a3, __int64 a4, __int64 a5, int a6, __int64 a7, char a8, __int64 a9, char a10)
{
__int64 result; // rax
int v11; // [rsp+4h] [rbp-14h] BYREF
int v12; // [rsp+8h] [rbp-10h] BYREF
int v13[3]; // [rsp+Ch] [rbp-Ch] BYREF

v13[0] = a2;
v12 = a3;
v11 = a6;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 == 102 )
{
result = zgeru_(v13, &v12, a4, a5, &v11, a7, &a8, a9, &a10);
}
else if ( a1 == 101 )
{
RowMajorStrg = 1;
result = zgeru_(&v12, v13, a4, a7, &a8, a5, &v11, a9, &a10);
}
else
{
result = cblas_xerbla(1LL, "cblas_zgeru", "Illegal Order setting, %d\n", a1);
}
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}

original_code:
void cblas_zgeru(const enum CBLAS_ORDER order, const int M, const int N,
                 const void *alpha, const void *X, const int incX,
                 const void *Y, const int incY, void *A, const int lda)
{
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      zgeru_( &M, &N, alpha, X, &incX, Y, &incY, A,
                      &lda);
   }
   else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      zgeru_( &N, &M, alpha, Y, &incY, X, &incX, A,
                      &lda);
   }
   else cblas_xerbla(1, "cblas_zgeru", "Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

canonical_original_code:
void cblas_zgeru(enum CBLAS_ORDER order, int M, int N, void *alpha, void *X, int incX, void *Y, int incY, void *A, int lda)
{
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      zgeru_( &M, &N, alpha, X, &incX, Y, &incY, A,
                      &lda);
   }
   else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      zgeru_( &N, &M, alpha, Y, &incY, X, &incX, A,
                      &lda);
   }
   else cblas_xerbla(1, "cblas_zgeru", "Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

variable_types: enum CBLAS_ORDER { CblasRowMajor=101, CblasColMajor=102 }

variable_types:
X
void *

variable_types: incX int

variable_types:
A
void *

variable_types: lda int


original_code:
void cblas_zgerc(const enum CBLAS_ORDER order, const int M, const int N,
                 const void *alpha, const void *X, const int incX,
                 const void *Y, const int incY, void *A, const int lda)
{
   int n, i, tincy, incy=incY;
   double *y=(double *)Y, *yy=(double *)Y, *ty, *st;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      zgerc_( &M, &N, alpha, X, &incX, Y, &incy, A,
                      &lda);
   } else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (N > 0)
      {
         n = N << 1;
         y = malloc(n*sizeof(double));
         ty = y;
         if( incY > 0 ) {
            i = incY << 1;
            tincy = 2;
            st= y+n;
         } else {
            i = incY *(-2);
            tincy = -2;
            st = y-2;
            y +=(n-2);
         }
         do
         {
            *y = *yy;
            y[1] = -yy[1];
            y += tincy ;
            yy += i;
         }
         while (y != st);
         y = ty;
            incy = 1;
      }
      else y = (double *) Y;
      zgeru_( &N, &M, alpha, y, &incy, X, &incX, A,
                      &lda);
      if(Y!=y)
         free(y);
   } else cblas_xerbla(1, "cblas_zgerc", "Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

canonical_original_code:
void cblas_zgerc(enum CBLAS_ORDER order, int M, int N, void *alpha, void *X, int incX, void *Y, int incY, void *A, int lda)
{
   int n; int i; int tincy; int incy = incY;
   double *y = (double *)Y; double *yy = (double *)Y; double *ty; double *st;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      zgerc_( &M, &N, alpha, X, &incX, Y, &incy, A,
                      &lda);
   } else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (N > 0)
      {
         n = N << 1;
         y = malloc(n*sizeof(double));
         ty = y;
         if( incY > 0 ) {
            i = incY << 1;
            tincy = 2;
            st= y+n;
         } else {
            i = incY *(-2);
            tincy = -2;
            st = y-2;
            y +=(n-2);
         }
         do
         {
            *y = *yy;
            y[1] = -yy[1];
            y += tincy ;
            yy += i;
         }
         while (y != st);
         y = ty;
            incy = 1;
      }
      else y = (double *) Y;
      zgeru_( &N, &M, alpha, y, &incy, X, &incX, A,
                      &lda);
      if(Y!=y)
         free(y);
   } else cblas_xerbla(1, "cblas_zgerc", "Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

variable_types: incY int

variable_types: n int

variable_types:
y
double *

variable_types:
yy
double *

variable_types:
ty
double *

variable_types:
st
double *

variable_types: RowMajorStrg int


decompiled_code:
float __fastcall cblas_sasum(int a1, __int64 a2, int a3)
{
int v4; // [rsp+8h] [rbp-20h] BYREF
int v5[4]; // [rsp+Ch] [rbp-1Ch] BYREF
float v6[3]; // [rsp+1Ch] [rbp-Ch] BYREF

v5[0] = a1;
v4 = a3;
sasumsub_(v5, a2, &v4, v6);
return v6[0];
}

canonical_decompiled_code:
float __fastcall func0(int a1, __int64 a2, int a3)
{
int v4; // [rsp+8h] [rbp-20h] BYREF
int v5[4]; // [rsp+Ch] [rbp-1Ch] BYREF
float v6[3]; // [rsp+1Ch] [rbp-Ch] BYREF

v5[0] = a1;
v4 = a3;
sasumsub_(v5, a2, &v4, v6);
return v6[0];
}

original_code:
float cblas_sasum( const int N, const float *X, const int incX)
{
   float asum;
   sasumsub_( &N, X, &incX, &asum);
   return asum;
}

canonical_original_code:
float cblas_sasum(int N, float *X, int incX)
{
   float asum;
   sasumsub_( &N, X, &incX, &asum);
   return asum;
}

variable_types: N int

variable_types:
X
float *

variable_types: asum float


decompiled_code:
__int64 __fastcall cblas_sgbmv(unsigned int a1, unsigned int a2, int a3, int a4, int a5, int a6, float a7, float a8, __int64 a9, char a10, __int64 a11, char a12, __int64 a13, char a14)
{
__int64 result; // rax
float v15; // [rsp+8h] [rbp-30h] BYREF
float v16; // [rsp+Ch] [rbp-2Ch] BYREF
int v17; // [rsp+10h] [rbp-28h] BYREF
int v18; // [rsp+14h] [rbp-24h] BYREF
int v19; // [rsp+18h] [rbp-20h] BYREF
int v20[4]; // [rsp+1Ch] [rbp-1Ch] BYREF
char v21[9]; // [rsp+2Fh] [rbp-9h] BYREF

v20[0] = a3;
v19 = a4;
v18 = a5;
v17 = a6;
v16 = a7;
v15 = a8;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 != 102 )
{
if ( a1 != 101 )
{
result = cblas_xerbla(1LL, "cblas_sgbmv", "Illegal Order setting, %d\n", a1);
goto LABEL_20;
}
RowMajorStrg = 1;
switch ( a2 )
{
case 'o':
v21[0] = 84;
goto LABEL_16;
case 'p':
v21[0] = 78;
goto LABEL_16;
case 'q':
v21[0] = 78;
LABEL_16:
result = sgbmv_(v21, &v19, v20, &v17, &v18, &v16, a9, &a10, a11, &a12, &v15, a13, &a14);
goto LABEL_20;
}
LABEL_14:
result = cblas_xerbla(2LL, "cblas_sgbmv", "Illegal TransA setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
switch ( a2 )
{
case 'o':
v21[0] = 78;
break;
case 'p':
v21[0] = 84;
break;
case 'q':
v21[0] = 67;
break;
default:
goto LABEL_14;
}
result = sgbmv_(v21, v20, &v19, &v18, &v17, &v16, a9, &a10, a11, &a12, &v15, a13, &a14);
LABEL_20:
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func0(unsigned int a1, unsigned int a2, int a3, int a4, int a5, int a6, float a7, float a8, __int64 a9, char a10, __int64 a11, char a12, __int64 a13, char a14)
{
__int64 result; // rax
float v15; // [rsp+8h] [rbp-30h] BYREF
float v16; // [rsp+Ch] [rbp-2Ch] BYREF
int v17; // [rsp+10h] [rbp-28h] BYREF
int v18; // [rsp+14h] [rbp-24h] BYREF
int v19; // [rsp+18h] [rbp-20h] BYREF
int v20[4]; // [rsp+1Ch] [rbp-1Ch] BYREF
char v21[9]; // [rsp+2Fh] [rbp-9h] BYREF

v20[0] = a3;
v19 = a4;
v18 = a5;
v17 = a6;
v16 = a7;
v15 = a8;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 != 102 )
{
if ( a1 != 101 )
{
result = cblas_xerbla(1LL, "cblas_sgbmv", "Illegal Order setting, %d\n", a1);
goto LABEL_20;
}
RowMajorStrg = 1;
switch ( a2 )
{
case 'o':
v21[0] = 84;
goto LABEL_16;
case 'p':
v21[0] = 78;
goto LABEL_16;
case 'q':
v21[0] = 78;
LABEL_16:
result = sgbmv_(v21, &v19, v20, &v17, &v18, &v16, a9, &a10, a11, &a12, &v15, a13, &a14);
goto LABEL_20;
}
LABEL_14:
result = cblas_xerbla(2LL, "cblas_sgbmv", "Illegal TransA setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
switch ( a2 )
{
case 'o':
v21[0] = 78;
break;
case 'p':
v21[0] = 84;
break;
case 'q':
v21[0] = 67;
break;
default:
goto LABEL_14;
}
result = sgbmv_(v21, v20, &v19, &v18, &v17, &v16, a9, &a10, a11, &a12, &v15, a13, &a14);
LABEL_20:
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}

original_code:
void cblas_sgbmv(const enum CBLAS_ORDER order,
                 const enum CBLAS_TRANSPOSE TransA, const int M, const int N,
                 const int KL, const int KU,
                 const float alpha, const float *A, const int lda,
                 const float *X, const int incX, const float beta,
                 float *Y, const int incY)
{
   char TA;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      if (TransA == CblasNoTrans) TA = 'N';
      else if (TransA == CblasTrans) TA = 'T';
      else if (TransA == CblasConjTrans) TA = 'C';
      else
      {
         cblas_xerbla(2, "cblas_sgbmv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      sgbmv_(&TA, &M, &N, &KL, &KU, &alpha,
                     A, &lda, X, &incX, &beta, Y, &incY);
   }
   else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (TransA == CblasNoTrans) TA = 'T';
      else if (TransA == CblasTrans) TA = 'N';
      else if (TransA == CblasConjTrans) TA = 'N';
      else
      {
         cblas_xerbla(2, "cblas_sgbmv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      sgbmv_(&TA, &N, &M, &KU, &KL, &alpha,
                     A ,&lda, X, &incX, &beta, Y, &incY);
   }
   else cblas_xerbla(1, "cblas_sgbmv", "Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

canonical_original_code:
void cblas_sgbmv(enum CBLAS_ORDER order, enum CBLAS_TRANSPOSE TransA, int M, int N, int KL, int KU, float alpha, float *A, int lda, float *X, int incX, float beta, float *Y, int incY)
{
   char TA;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      if (TransA == CblasNoTrans) TA = 'N';
      else if (TransA == CblasTrans) TA = 'T';
      else if (TransA == CblasConjTrans) TA = 'C';
      else
      {
         cblas_xerbla(2, "cblas_sgbmv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      sgbmv_(&TA, &M, &N, &KL, &KU, &alpha,
                     A, &lda, X, &incX, &beta, Y, &incY);
   }
   else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (TransA == CblasNoTrans) TA = 'T';
      else if (TransA == CblasTrans) TA = 'N';
      else if (TransA == CblasConjTrans) TA = 'N';
      else
      {
         cblas_xerbla(2, "cblas_sgbmv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      sgbmv_(&TA, &N, &M, &KU, &KL, &alpha,
                     A ,&lda, X, &incX, &beta, Y, &incY);
   }
   else cblas_xerbla(1, "cblas_sgbmv", "Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

variable_types: enum CBLAS_TRANSPOSE { CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113 }

variable_types: M int

variable_types: KL int

variable_types: KU int

variable_types: alpha float

variable_types:
A
float *

variable_types: beta float

variable_types:
Y
float *

variable_types: TA char


decompiled_code:
float __fastcall cblas_scnrm2(int a1, __int64 a2, int a3)
{
int v4; // [rsp+8h] [rbp-20h] BYREF
int v5[4]; // [rsp+Ch] [rbp-1Ch] BYREF
float v6[3]; // [rsp+1Ch] [rbp-Ch] BYREF

v5[0] = a1;
v4 = a3;
scnrm2sub_(v5, a2, &v4, v6);
return v6[0];
}

canonical_decompiled_code:
float __fastcall func0(int a1, __int64 a2, int a3)
{
int v4; // [rsp+8h] [rbp-20h] BYREF
int v5[4]; // [rsp+Ch] [rbp-1Ch] BYREF
float v6[3]; // [rsp+1Ch] [rbp-Ch] BYREF

v5[0] = a1;
v4 = a3;
scnrm2sub_(v5, a2, &v4, v6);
return v6[0];
}

original_code:
float cblas_scnrm2( const int N, const void *X, const int incX)
{
   float nrm2;
   scnrm2sub_( &N, X, &incX, &nrm2);
   return nrm2;
}

canonical_original_code:
float cblas_scnrm2(int N, void *X, int incX)
{
   float nrm2;
   scnrm2sub_( &N, X, &incX, &nrm2);
   return nrm2;
}

variable_types:
X
void *

variable_types: incX int


decompiled_code:
__int64 __fastcall cblas_dtbmv(unsigned int a1, unsigned int a2, unsigned int a3, __int64 a4, int a5, int a6, __int64 a7, char a8, __int64 a9, char a10)
{
__int64 result; // rax
int v11; // [rsp+8h] [rbp-20h] BYREF
int v12[4]; // [rsp+Ch] [rbp-1Ch] BYREF
char v13; // [rsp+1Dh] [rbp-Bh] BYREF
char v14; // [rsp+1Eh] [rbp-Ah] BYREF
char v15[9]; // [rsp+1Fh] [rbp-9h] BYREF

v12[0] = a5;
v11 = a6;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 != 102 )
{
if ( a1 != 101 )
{
result = cblas_xerbla(1LL, "cblas_dtbmv", "Illegal Order setting, %d\n", a1);
goto LABEL_39;
}
RowMajorStrg = 1;
if ( a2 == 121 )
{
v14 = 76;
LABEL_6:
switch ( a3 )
{
case 'o':
v15[0] = 84;
break;
case 'p':
v15[0] = 78;
break;
case 'q':
v15[0] = 78;
break;
default:
LABEL_25:
result = cblas_xerbla(3LL, "cblas_dtbmv", "Illegal TransA setting, %d\n", a3);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
if ( (_DWORD)a4 == 132 )
{
v13 = 85;
}
else
{
if ( (_DWORD)a4 != 131 )
{
result = cblas_xerbla(4LL, "cblas_dtbmv", "Illegal Uplo setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
v13 = 78;
}
goto LABEL_23;
}
if ( a2 == 122 )
{
v14 = 85;
goto LABEL_6;
}
LABEL_18:
result = cblas_xerbla(2LL, "cblas_dtbmv", "Illegal Uplo setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
if ( a2 == 121 )
{
v14 = 85;
}
else
{
if ( a2 != 122 )
goto LABEL_18;
v14 = 76;
}
switch ( a3 )
{
case 'o':
v15[0] = 78;
break;
case 'p':
v15[0] = 84;
break;
case 'q':
v15[0] = 67;
break;
default:
goto LABEL_25;
}
if ( (_DWORD)a4 == 132 )
{
v13 = 85;
}
else
{
if ( (_DWORD)a4 != 131 )
{
result = cblas_xerbla(4LL, "cblas_dtbmv", "Illegal Diag setting, %d\n", a4);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
v13 = 78;
}
LABEL_23:
result = dtbmv_(&v14, v15, &v13, v12, &v11, a7, &a8, a9, &a10);
LABEL_39:
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func0(unsigned int a1, unsigned int a2, unsigned int a3, __int64 a4, int a5, int a6, __int64 a7, char a8, __int64 a9, char a10)
{
__int64 result; // rax
int v11; // [rsp+8h] [rbp-20h] BYREF
int v12[4]; // [rsp+Ch] [rbp-1Ch] BYREF
char v13; // [rsp+1Dh] [rbp-Bh] BYREF
char v14; // [rsp+1Eh] [rbp-Ah] BYREF
char v15[9]; // [rsp+1Fh] [rbp-9h] BYREF

v12[0] = a5;
v11 = a6;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 != 102 )
{
if ( a1 != 101 )
{
result = cblas_xerbla(1LL, "cblas_dtbmv", "Illegal Order setting, %d\n", a1);
goto LABEL_39;
}
RowMajorStrg = 1;
if ( a2 == 121 )
{
v14 = 76;
LABEL_6:
switch ( a3 )
{
case 'o':
v15[0] = 84;
break;
case 'p':
v15[0] = 78;
break;
case 'q':
v15[0] = 78;
break;
default:
LABEL_25:
result = cblas_xerbla(3LL, "cblas_dtbmv", "Illegal TransA setting, %d\n", a3);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
if ( (_DWORD)a4 == 132 )
{
v13 = 85;
}
else
{
if ( (_DWORD)a4 != 131 )
{
result = cblas_xerbla(4LL, "cblas_dtbmv", "Illegal Uplo setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
v13 = 78;
}
goto LABEL_23;
}
if ( a2 == 122 )
{
v14 = 85;
goto LABEL_6;
}
LABEL_18:
result = cblas_xerbla(2LL, "cblas_dtbmv", "Illegal Uplo setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
if ( a2 == 121 )
{
v14 = 85;
}
else
{
if ( a2 != 122 )
goto LABEL_18;
v14 = 76;
}
switch ( a3 )
{
case 'o':
v15[0] = 78;
break;
case 'p':
v15[0] = 84;
break;
case 'q':
v15[0] = 67;
break;
default:
goto LABEL_25;
}
if ( (_DWORD)a4 == 132 )
{
v13 = 85;
}
else
{
if ( (_DWORD)a4 != 131 )
{
result = cblas_xerbla(4LL, "cblas_dtbmv", "Illegal Diag setting, %d\n", a4);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
v13 = 78;
}
LABEL_23:
result = dtbmv_(&v14, v15, &v13, v12, &v11, a7, &a8, a9, &a10);
LABEL_39:
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}

original_code:
void cblas_dtbmv(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
                 const enum CBLAS_TRANSPOSE TransA, const enum CBLAS_DIAG Diag,
                 const int N, const int K, const double *A, const int lda,
                 double *X, const int incX)
{
   char TA;
   char UL;
   char DI;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      if (Uplo == CblasUpper) UL = 'U';
      else if (Uplo == CblasLower) UL = 'L';
      else
      {
         cblas_xerbla(2, "cblas_dtbmv","Illegal Uplo setting, %d\n", Uplo);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if (TransA == CblasNoTrans) TA = 'N';
      else if (TransA == CblasTrans) TA = 'T';
      else if (TransA == CblasConjTrans) TA = 'C';
      else
      {
         cblas_xerbla(3, "cblas_dtbmv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if (Diag == CblasUnit) DI = 'U';
      else if (Diag == CblasNonUnit) DI = 'N';
      else
      {
         cblas_xerbla(4, "cblas_dtbmv","Illegal Diag setting, %d\n", Diag);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      dtbmv_( &UL, &TA, &DI, &N, &K, A, &lda, X,
                      &incX);
   }
   else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (Uplo == CblasUpper) UL = 'L';
      else if (Uplo == CblasLower) UL = 'U';
      else
      {
         cblas_xerbla(2, "cblas_dtbmv","Illegal Uplo setting, %d\n", Uplo);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if (TransA == CblasNoTrans) TA = 'T';
      else if (TransA == CblasTrans) TA = 'N';
      else if (TransA == CblasConjTrans) TA = 'N';
      else
      {
         cblas_xerbla(3, "cblas_dtbmv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if (Diag == CblasUnit) DI = 'U';
      else if (Diag == CblasNonUnit) DI = 'N';
      else
      {
         cblas_xerbla(4, "cblas_dtbmv","Illegal Uplo setting, %d\n", Uplo);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      dtbmv_( &UL, &TA, &DI, &N, &K, A, &lda, X,
                      &incX);
   }
   else cblas_xerbla(1, "cblas_dtbmv", "Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
}

canonical_original_code:
void cblas_dtbmv(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, enum CBLAS_TRANSPOSE TransA, enum CBLAS_DIAG Diag, int N, int K, double *A, int lda, double *X, int incX)
{
   char TA;
   char UL;
   char DI;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      if (Uplo == CblasUpper) UL = 'U';
      else if (Uplo == CblasLower) UL = 'L';
      else
      {
         cblas_xerbla(2, "cblas_dtbmv","Illegal Uplo setting, %d\n", Uplo);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if (TransA == CblasNoTrans) TA = 'N';
      else if (TransA == CblasTrans) TA = 'T';
      else if (TransA == CblasConjTrans) TA = 'C';
      else
      {
         cblas_xerbla(3, "cblas_dtbmv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if (Diag == CblasUnit) DI = 'U';
      else if (Diag == CblasNonUnit) DI = 'N';
      else
      {
         cblas_xerbla(4, "cblas_dtbmv","Illegal Diag setting, %d\n", Diag);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      dtbmv_( &UL, &TA, &DI, &N, &K, A, &lda, X,
                      &incX);
   }
   else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (Uplo == CblasUpper) UL = 'L';
      else if (Uplo == CblasLower) UL = 'U';
      else
      {
         cblas_xerbla(2, "cblas_dtbmv","Illegal Uplo setting, %d\n", Uplo);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if (TransA == CblasNoTrans) TA = 'T';
      else if (TransA == CblasTrans) TA = 'N';
      else if (TransA == CblasConjTrans) TA = 'N';
      else
      {
         cblas_xerbla(3, "cblas_dtbmv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if (Diag == CblasUnit) DI = 'U';
      else if (Diag == CblasNonUnit) DI = 'N';
      else
      {
         cblas_xerbla(4, "cblas_dtbmv","Illegal Uplo setting, %d\n", Uplo);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      dtbmv_( &UL, &TA, &DI, &N, &K, A, &lda, X,
                      &incX);
   }
   else cblas_xerbla(1, "cblas_dtbmv", "Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
}

variable_types: enum CBLAS_ORDER { CblasRowMajor=101, CblasColMajor=102 }

variable_types: enum CBLAS_UPLO { CblasUpper=121, CblasLower=122 }

variable_types: enum CBLAS_DIAG { CblasNonUnit=131, CblasUnit=132 }

variable_types: K int

variable_types:
A
double *

variable_types: lda int

variable_types:
X
double *

variable_types: UL char

variable_types: DI char


decompiled_code:
float __fastcall cblas_sdsdot(int a1, __int64 a2, int a3, __int64 a4, int a5, float a6)
{
int v7; // [rsp+8h] [rbp-28h] BYREF
int v8; // [rsp+Ch] [rbp-24h] BYREF
float v9; // [rsp+10h] [rbp-20h] BYREF
int v10[4]; // [rsp+14h] [rbp-1Ch] BYREF
float v11[3]; // [rsp+24h] [rbp-Ch] BYREF

v10[0] = a1;
v9 = a6;
v8 = a3;
v7 = a5;
sdsdotsub_(v10, &v9, a2, &v8, a4, &v7, v11);
return v11[0];
}

canonical_decompiled_code:
float __fastcall func0(int a1, __int64 a2, int a3, __int64 a4, int a5, float a6)
{
int v7; // [rsp+8h] [rbp-28h] BYREF
int v8; // [rsp+Ch] [rbp-24h] BYREF
float v9; // [rsp+10h] [rbp-20h] BYREF
int v10[4]; // [rsp+14h] [rbp-1Ch] BYREF
float v11[3]; // [rsp+24h] [rbp-Ch] BYREF

v10[0] = a1;
v9 = a6;
v8 = a3;
v7 = a5;
sdsdotsub_(v10, &v9, a2, &v8, a4, &v7, v11);
return v11[0];
}

original_code:
float cblas_sdsdot( const int N, const float alpha, const float *X,
                      const int incX, const float *Y, const int incY)
{
   float dot;
   sdsdotsub_( &N, &alpha, X, &incX, Y, &incY, &dot);
   return dot;
}

canonical_original_code:
float cblas_sdsdot(int N, float alpha, float *X, int incX, float *Y, int incY)
{
   float dot;
   sdsdotsub_( &N, &alpha, X, &incX, Y, &incY, &dot);
   return dot;
}

variable_types: N int

variable_types:
X
float *

variable_types: incY int

variable_types: dot float


decompiled_code:
__int64 __fastcall cblas_ssyr(unsigned int a1, unsigned int a2, int a3, __int64 a4, int a5, float a6)
{
__int64 result; // rax
int v7; // [rsp+4h] [rbp-24h] BYREF
float v8; // [rsp+8h] [rbp-20h] BYREF
int v9[4]; // [rsp+Ch] [rbp-1Ch] BYREF
char v10[9]; // [rsp+1Fh] [rbp-9h] BYREF

v9[0] = a3;
v8 = a6;
v7 = a5;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 == 102 )
{
if ( a2 == 122 )
{
v10[0] = 76;
goto LABEL_6;
}
if ( a2 == 121 )
{
v10[0] = 85;
goto LABEL_6;
}
LABEL_11:
result = cblas_xerbla(2LL, "cblas_ssyr", "Illegal Uplo setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
if ( a1 != 101 )
{
result = cblas_xerbla(1LL, "cblas_ssyr", "Illegal Order setting, %d\n", a1);
goto LABEL_15;
}
RowMajorStrg = 1;
if ( a2 == 122 )
{
v10[0] = 85;
goto LABEL_6;
}
if ( a2 != 121 )
goto LABEL_11;
v10[0] = 76;
LABEL_6:
result = ssyr_(v10, v9, &v8, a4, &v7);
LABEL_15:
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}

canonical_decompiled_code:
__int64 __fastcall func0(unsigned int a1, unsigned int a2, int a3, __int64 a4, int a5, float a6)
{
__int64 result; // rax
int v7; // [rsp+4h] [rbp-24h] BYREF
float v8; // [rsp+8h] [rbp-20h] BYREF
int v9[4]; // [rsp+Ch] [rbp-1Ch] BYREF
char v10[9]; // [rsp+1Fh] [rbp-9h] BYREF

v9[0] = a3;
v8 = a6;
v7 = a5;
RowMajorStrg = 0;
CBLAS_CallFromC = 1;
if ( a1 == 102 )
{
if ( a2 == 122 )
{
v10[0] = 76;
goto LABEL_6;
}
if ( a2 == 121 )
{
v10[0] = 85;
goto LABEL_6;
}
LABEL_11:
result = cblas_xerbla(2LL, "cblas_ssyr", "Illegal Uplo setting, %d\n", a2);
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}
if ( a1 != 101 )
{
result = cblas_xerbla(1LL, "cblas_ssyr", "Illegal Order setting, %d\n", a1);
goto LABEL_15;
}
RowMajorStrg = 1;
if ( a2 == 122 )
{
v10[0] = 85;
goto LABEL_6;
}
if ( a2 != 121 )
goto LABEL_11;
v10[0] = 76;
LABEL_6:
result = ssyr_(v10, v9, &v8, a4, &v7);
LABEL_15:
CBLAS_CallFromC = 0;
RowMajorStrg = 0;
return result;
}

original_code:
void cblas_ssyr(const enum CBLAS_ORDER order, const enum CBLAS_UPLO Uplo,
                const int N, const float alpha, const float *X,
                const int incX, float *A, const int lda)
{
   char UL;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      if (Uplo == CblasLower) UL = 'L';
      else if (Uplo == CblasUpper) UL = 'U';
      else
      {
         cblas_xerbla(2, "cblas_ssyr","Illegal Uplo setting, %d\n",Uplo );
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      ssyr_(&UL, &N, &alpha, X, &incX, A, &lda);
   } else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (Uplo == CblasLower) UL = 'U';
      else if (Uplo == CblasUpper) UL = 'L';
      else
      {
         cblas_xerbla(2, "cblas_ssyr","Illegal Uplo setting, %d\n",Uplo );
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      ssyr_(&UL, &N, &alpha, X, &incX, A, &lda);
   } else cblas_xerbla(1, "cblas_ssyr", "Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

canonical_original_code:
void cblas_ssyr(enum CBLAS_ORDER order, enum CBLAS_UPLO Uplo, int N, float alpha, float *X, int incX, float *A, int lda)
{
   char UL;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      if (Uplo == CblasLower) UL = 'L';
      else if (Uplo == CblasUpper) UL = 'U';
      else
      {
         cblas_xerbla(2, "cblas_ssyr","Illegal Uplo setting, %d\n",Uplo );
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      ssyr_(&UL, &N, &alpha, X, &incX, A, &lda);
   } else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (Uplo == CblasLower) UL = 'U';
      else if (Uplo == CblasUpper) UL = 'L';
      else
      {
         cblas_xerbla(2, "cblas_ssyr","Illegal Uplo setting, %d\n",Uplo );
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      ssyr_(&UL, &N, &alpha, X, &incX, A, &lda);
   } else cblas_xerbla(1, "cblas_ssyr", "Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

variable_types: alpha float

variable_types:
A
float *

variable_types: RowMajorStrg int


original_code:
void cblas_cgemv(const enum CBLAS_ORDER order,
                 const enum CBLAS_TRANSPOSE TransA, const int M, const int N,
                 const void *alpha, const void *A, const int lda,
                 const void *X, const int incX, const void *beta,
                 void *Y, const int incY)
{
   char TA;
   int n=0, i=0, incx=incX;
   const float *xx= (const float *)X;
   float ALPHA[2],BETA[2];
   int tincY, tincx;
   float *x=(float *)X, *y=(float *)Y, *st=0, *tx=0;
   const float *stx = x;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      if (TransA == CblasNoTrans) TA = 'N';
      else if (TransA == CblasTrans) TA = 'T';
      else if (TransA == CblasConjTrans) TA = 'C';
      else
      {
         cblas_xerbla(2, "cblas_cgemv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      cgemv_(&TA, &M, &N, alpha, A, &lda, X, &incx,
                beta, Y, &incY);
   }
   else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (TransA == CblasNoTrans) TA = 'T';
      else if (TransA == CblasTrans) TA = 'N';
      else if (TransA == CblasConjTrans)
      {
         ALPHA[0]= *( (const float *) alpha );
         ALPHA[1]= -( *( (const float *) alpha+1) );
         BETA[0]= *( (const float *) beta );
         BETA[1]= -( *( (const float *) beta+1 ) );
         TA = 'N';
         if (M > 0)
         {
            n = M << 1;
            x = malloc(n*sizeof(float));
            tx = x;
            if( incX > 0 ) {
               i = incX << 1 ;
               tincx = 2;
               st= x+n;
            } else {
               i = incX *(-2);
               tincx = -2;
               st = x-2;
               x +=(n-2);
            }
            do
            {
               *x = *xx;
               x[1] = -xx[1];
               x += tincx ;
               xx += i;
            }
            while (x != st);
            x=tx;
            incx = 1;
            if(incY > 0)
               tincY = incY;
            else
               tincY = -incY;
            y++;
            if (N > 0)
            {
               i = tincY << 1;
               n = i * N ;
               st = y + n;
               do {
                  *y = -(*y);
                  y += i;
               } while(y != st);
               y -= n;
            }
            stx = x;
         }
         else stx = (const float *)X;
      }
      else
      {
         cblas_xerbla(2, "cblas_cgemv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if (TransA == CblasConjTrans)
         cgemv_(&TA, &N, &M, ALPHA, A, &lda, stx,
                &incx, BETA, Y, &incY);
      else
         cgemv_(&TA, &N, &M, alpha, A, &lda, x,
                &incx, beta, Y, &incY);
      if (TransA == CblasConjTrans)
      {
         if (x != (const float *)X) free(x);
         if (N > 0)
         {
            do
            {
               *y = -(*y);
               y += i;
            }
            while (y != st);
         }
      }
   }
   else cblas_xerbla(1, "cblas_cgemv", "Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

canonical_original_code:
void cblas_cgemv(enum CBLAS_ORDER order, enum CBLAS_TRANSPOSE TransA, int M, int N, void *alpha, void *A, int lda, void *X, int incX, void *beta, void *Y, int incY)
{
   char TA;
   int n = 0; int i = 0; int incx = incX;
   float *xx = (const float *)X;
   float ALPHA[2]; float BETA[2];
   int tincY; int tincx;
   float *x = (float *)X; float *y = (float *)Y; float *st = 0; float *tx = 0;
   float *stx = x;
   extern int CBLAS_CallFromC;
   extern int RowMajorStrg;
   RowMajorStrg = 0;
   CBLAS_CallFromC = 1;
   if (order == CblasColMajor)
   {
      if (TransA == CblasNoTrans) TA = 'N';
      else if (TransA == CblasTrans) TA = 'T';
      else if (TransA == CblasConjTrans) TA = 'C';
      else
      {
         cblas_xerbla(2, "cblas_cgemv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      cgemv_(&TA, &M, &N, alpha, A, &lda, X, &incx,
                beta, Y, &incY);
   }
   else if (order == CblasRowMajor)
   {
      RowMajorStrg = 1;
      if (TransA == CblasNoTrans) TA = 'T';
      else if (TransA == CblasTrans) TA = 'N';
      else if (TransA == CblasConjTrans)
      {
         ALPHA[0]= *( (float *) alpha );
         ALPHA[1]= -( *( (float *) alpha+1) );
         BETA[0]= *( (float *) beta );
         BETA[1]= -( *( (float *) beta+1 ) );
         TA = 'N';
         if (M > 0)
         {
            n = M << 1;
            x = malloc(n*sizeof(float));
            tx = x;
            if( incX > 0 ) {
               i = incX << 1 ;
               tincx = 2;
               st= x+n;
            } else {
               i = incX *(-2);
               tincx = -2;
               st = x-2;
               x +=(n-2);
            }
            do
            {
               *x = *xx;
               x[1] = -xx[1];
               x += tincx ;
               xx += i;
            }
            while (x != st);
            x=tx;
            incx = 1;
            if(incY > 0)
               tincY = incY;
            else
               tincY = -incY;
            y++;
            if (N > 0)
            {
               i = tincY << 1;
               n = i * N ;
               st = y + n;
               do {
                  *y = -(*y);
                  y += i;
               } while(y != st);
               y -= n;
            }
            stx = x;
         }
         else stx = (float *)X;
      }
      else
      {
         cblas_xerbla(2, "cblas_cgemv","Illegal TransA setting, %d\n", TransA);
         CBLAS_CallFromC = 0;
         RowMajorStrg = 0;
         return;
      }
      if (TransA == CblasConjTrans)
         cgemv_(&TA, &N, &M, ALPHA, A, &lda, stx,
                &incx, BETA, Y, &incY);
      else
         cgemv_(&TA, &N, &M, alpha, A, &lda, x,
                &incx, beta, Y, &incY);
      if (TransA == CblasConjTrans)
      {
         if (x != (float *)X) free(x);
         if (N > 0)
         {
            do
            {
               *y = -(*y);
               y += i;
            }
            while (y != st);
         }
      }
   }
   else cblas_xerbla(1, "cblas_cgemv", "Illegal Order setting, %d\n", order);
   CBLAS_CallFromC = 0;
   RowMajorStrg = 0;
   return;
}

variable_types: enum CBLAS_TRANSPOSE { CblasNoTrans=111, CblasTrans=112, CblasConjTrans=113 }

variable_types: M int

variable_types:
alpha
void *

variable_types:
A
void *

variable_types:
X
void *

variable_types: incX int

variable_types:
beta
void *

variable_types:
Y
void *

variable_types: TA char

variable_types: n int

variable_types: i int

variable_types: incx int

variable_types:
xx
float *

variable_types:
ALPHA
float [2]

variable_types:
BETA
float [2]

variable_types: tincY int

variable_types: tincx int

variable_types:
x
float *

variable_types:
y
float *

variable_types:
st
float *

variable_types:
tx
float *

variable_types:
stx
float *


decompiled_code:
__int64 __fastcall cblas_drotmg(__int64 a1, __int64 a2, __int64 a3, __int64 a4, double a5)
{
double v6[2]; // [rsp+8h] [rbp-10h] BYREF

v6[0] = a5;
return drotmg_(a1, a2, a3, v6, a4);
}

canonical_decompiled_code:
__int64 __fastcall func0(__int64 a1, __int64 a2, __int64 a3, __int64 a4, double a5)
{
double v6[2]; // [rsp+8h] [rbp-10h] BYREF

v6[0] = a5;
return drotmg_(a1, a2, a3, v6, a4);
}

original_code:
void cblas_drotmg( double *d1, double *d2, double *b1,
                        const double b2, double *p)
{
   drotmg_(d1,d2,b1,&b2,p);
}

canonical_original_code:
void cblas_drotmg(double *d1, double *d2, double *b1, double b2, double *p)
{
   drotmg_(d1,d2,b1,&b2,p);
}

variable_types:
p
double *