Ассемблерная вставка, Error: "invalid use of register"

Не работает ассемблерная вставка, хочу посчитать обратную матрицу, используя ассемблер. Но для проверки параллельно считаю на Си для проверки вычислений. Но получаю ошибку "junk '2' after expression"

Код:

#include<stdio.h>
#include<time.h>
#include<math.h>
#include<locale.h>
#include<malloc.h>
#include<stdlib.h>
#define scanf_s scanf // была ошибка undefined reference to scanf_s


int main()
{


const int n=3;
double det;
//////////////////////
// выделение памяти //
//////////////////////
double **matr; // для матрицы
matr = (double**) malloc(n*sizeof(double*));
 for (int i=0; i<n; ++i)
     matr[i] = (double*) malloc(n*sizeof(double));
 if (NULL == matr) {
         printf("Память не выделилась для matr\n");
         exit(1);
    }
 // *для матрцы миноров* //
 double **min; // для матрицы
min = (double**) malloc(n*sizeof(double*));
 for (int i=0; i<n; ++i)
     min[i] = (double*) malloc(n*sizeof(double));
 if (NULL == min) {
         printf("Память не выделилась для min\n");
         exit(1);
    }
// *для матрицы алгебраических дополнений* //
double **algdop; // для матрицы
algdop = (double**) malloc(n*sizeof(double*));
 for (int i=0; i<n; ++i)
     algdop[i] = (double*) malloc(n*sizeof(double));
 if (NULL == algdop) {
         printf("Память не выделилась для algdop\n");
         exit(1);
    }
// *для транспонированной матрицы * //
double **tmatr; // для матрицы
tmatr = (double**) malloc(n*sizeof(double*));
 for (int i=0; i<n; ++i)
     tmatr[i] = (double*) malloc(n*sizeof(double));
 if (NULL == tmatr) {
         printf("Память не выделилась для tmatr\n");
         exit(1);
    }
// *для обратной матрицы * //
double **obr_matr; // для матрицы
obr_matr = (double**) malloc(n*sizeof(double*));
 for (int i=0; i<n; ++i)
     obr_matr[i] = (double*) malloc(n*sizeof(double));
 if (NULL == obr_matr) {
         printf("Память не выделилась для obr_matr\n");
         exit(1);
    }
    

 ////////////////////////
 // заполнение матрицы //
 ////////////////////////
for (int i = 0; i < n; i++) { 
    for (int j = 0; j < n; j++) {
        printf("a[%d][%d] = ", i+1, j+1);
       // scanf_s("%lf", &matr[i][j]);
        if (!scanf("%lf", &matr[i][j])){ fflush(stdin); printf("Ошибка ввода! Нужно писать чиселки\n"); return 0;} 
    }
}
 /////////////////////////////
 // вывод введенной матрицы //
 /////////////////////////////
 printf("Введенная матрица:\n");
for (int i = 0; i < n; i++) {  //  проходим по строкам
    for (int j = 0; j < n; j++) { // проходим по столбцам
        printf("%g ", matr[i][j]);
   // printf("\n");
    }
    printf("\n");
}


/////////////////////////////
// нахождение определителя //
/////////////////////////////

 det = matr[0][0]*matr[1][1]*matr[2][2] + matr[0][1]*matr[1][2]*matr[2][0]
+ matr[1][0]*matr[2][1]*matr[0][2] - matr[2][0]*matr[1][1]*matr[0][2] -
matr[2][1]*matr[1][2]*matr[0][0] - matr[1][0]*matr[0][1]*matr[2][2];

printf("Определитель  (C) = %lf\n", det);

// асемблерная вставка //
//  6 слагаемых
// проходим по массиву

   
  double *D = &det; // указатель на определитель 
            
    
                                /////////////////////////
                                // нахождение  миноров //
                                /////////////////////////
                                ////////////////////////////
                                //     0        1      2  //   
                                //0 - [0][0] [0][1] [0][2]//
                                //1 - [1][0] [1][1] [1][2]//
                                //2 - [2][0] [2][1] [2][2]//
                                ////////////////////////////
        min[0][0]= matr[1][1] * matr[2][2] - matr[2][1] * matr[1][2];
        min[0][1]= matr[1][0] * matr[2][2] - matr[1][2] * matr[2][0];
        min[0][2]= matr[1][0] * matr[2][1] - matr[2][0] * matr[1][1];
        min[1][0]= matr[0][1] * matr[2][2] - matr[2][1] * matr[0][2];
        min[1][1]= matr[0][0] * matr[2][2] - matr[2][0] * matr[0][2];
        min[1][2]= matr[0][0] * matr[2][1] - matr[2][0] * matr[0][1];
        min[2][0]= matr[0][1] * matr[1][2] - matr[1][1] * matr[0][2];
        min[2][1]= matr[0][0] * matr[1][2] - matr[1][0] * matr[0][2];
        min[2][2]= matr[0][0] * matr[1][1] - matr[1][0] * matr[0][1];
        
      //  printf("Минор первого элемента матрицы = %lf\n", min[0][0]); // проверял правильность расчетов
      //  printf("Минор второго элемента матрицы = %lf\n", min[0][1]); // 
        
// *матрица алгебраических дополнений* //
for (int i = 0; i < n; i++){
    for (int j = 0; j < n; j++) {
            int k; // степень
            k=i+j;
            algdop[i][j]= pow(-1.0, k) *  min[i][j]; // матрица алгелраических дополнений
    }
}
// *вывод матрицы алгебраических дополнений* //
 printf("Матрица алгебраических дополнений:\n");
for (int i = 0; i < n; i++) {  //  проходим по строкам
    for (int j = 0; j < n; j++) { // проходим по столбцам
        printf("%g ", algdop[i][j]);
   // printf("\n");
    }
    printf("\n");
}
// *Транспонируем матрицу* //
        
           for (int i = 0; i < n; i++)   
        for (int j = 0; j < n; j++)
        tmatr[j][i] = algdop[i][j];
        
// *вывод транспонированной матрицы* //
 printf("Транспонированная матрица :\n");
for (int i = 0; i < n; i++) {  //  проходим по строкам
    for (int j = 0; j < n; j++) { // проходим по столбцам
        printf("%g ", tmatr[i][j]);
   // printf("\n");
    }
    printf("\n");
}


 // *вывод обратной матрицы до заполнения* //
 printf("Обратная матрица до заполнения :\n");
for (int i = 0; i < n; i++) {  //  проходим по строкам
    for (int j = 0; j < n; j++) { // проходим по столбцам
        printf("%g ", obr_matr[i][j]);
   // printf("\n");
    }
    printf("\n");
}

 ///////////////////////////////////////////
 // и наконец-то обратная матрицааааааааа //
 ///////////////////////////////////////////

       
           for (int i = 0; i < n; i++)   
        for (int j = 0; j < n; j++)
        obr_matr[i][j] = tmatr[i][j] / det;
        
        
// *вывод обратной матрицы (С)* //
 printf("Обратная матрица (C) :\n");
for (int i = 0; i < n; i++) {  //  проходим по строкам
    for (int j = 0; j < n; j++) { // проходим по столбцам
        printf("%g ", obr_matr[i][j]);
   // printf("\n");
    }
    printf("\n");
}
                 // асемблерная вставка //
asm
(
      ".intel_syntax noprefix\n" /*Синтаксис Intel, допускается опускать % перед именами регистров*/
      "\n\tmov rbx, %0"
      "\n\tmovss xmm0, [%1]" // в регистр xmm0 заночим определитель
      "\n\tmov rcx, 0"  // присваем начальное значение для счетчика по i (строкам)
     
      "\n\tloop1:"       // переход на след строчку
      "\n\tmov rdx, 0"  // присваем начальное значение для счетчика j //  находится в теле loop1, т к необходимо каждую строку проходить с нулевого элемента
      "\n\tinc rcx"     // увеличиваем счетчик (i) на 1
      "\n\tloop2:"      // переход к след эдементу в строчке
      "\n\tinc rdx"     // увеличиваем счетчик по элементам в строке (j)
      "\n\tmov rax, [rbx+8*rcx]"
      "\n\tlea r8, [rax+8*rdx]"
      "\n\tmovss xmm1, [r8]" // в xmm1 заносим значение элемента массива
      // тело цикла
      "\n\tdivss xmm1, xmm0"  // делим эллемент массива на определитель 

      "\n\tcmp rdx 2 "   // сравниваем счетчик по элементам строки (j) c 2
      "\n\tje loop1"     // и если он равен, переходим к loop1 т е след строке 
      "\n\tcmp rcx 2 "   // сравниваем счетчик строк (i) с 2
      "\n\tje loop3"     // и если истинно, переходим к loop3 т е завершаем работу
      "\n\tjmp loop2"    // если дошло до этой строки, то переходим к след элементу
      "\n\tloop3:"       // метка для завершения работы
    :  /*выходные операнды отсутствуют*/
    : "r"(tmatr), "r"(D) /*входные операторы*/
    : "%rax", "%rcx", "%xmm0", "%xmm1" ,  "memory", "cc" /*разрушаемые регистры (в формате %имя или memory --- для указания обизменении содержимого памяти, cc --- для указания на изменение регистра флагов) */
 );
   // *вывод обратной матрицы (Asm)* // выводится tmatr  так как мы изменяем значения в памяти
    printf("Обратная матрица (Asm) :\n");
   for (int i = 0; i < n; i++) {  //  проходим по строкам
       for (int j = 0; j < n; j++) { // проходим по столбцам
           printf("%g ", tmatr[i][j]);
      // printf("\n");
       }
       printf("\n");
   }
    
 /////////////////////////
 // освобождение памяти //
 /////////////////////////
  for (int i=0; i<n; ++i) {
      free (matr[i]);
      free (matr);          
}
// *для матрицы миноров* //
for (int i=0; i<n; ++i) {
      free (min[i]);
      free (min);          
}
// *для матрицы алгебраических дополнений* //
for (int i=0; i<n; ++i) {
      free (algdop[i]);
      free (algdop);          
}
 // *для транспонированной матрицы * //
  for (int i=0; i<n; ++i) {
      free (tmatr[i]);
      free (tmatr);          
}
// *для обратной матрицы * //
for (int i=0; i<n; ++i) {
      free (obr_matr[i]);
      free (obr_matr);          
}

return 0;        
}