#include <stdio.h>
#include <stdlib.h>

#define MAX 100

void matrix_multiply(int position, int *row, int *col, int **arr);
/*cely princip programu:
	nacteni az 100 matic jako 1D pole v arr[100] a do row[] col[] ulozit jejich vysku resp sirku.. do operator[] nacist operator..:D

	projede vsechny operatorz a pokud je '*'  posle do fce matrix_multiply

	podruhe projede vsechny matice a secte / odecte

	vypise vse..
*/

int main(int argc, char* argv[]){

	char operator[MAX];
	int row[MAX],col[MAX];
	int **arr = (int**)malloc(MAX*sizeof(int*));
	int i, j, load=0;

	//load matrixes into arr
	for (i=0; i<MAX; ++i){
		load = scanf("%i", &row[i]);
		load += scanf("%i", &col[i]);
		if(load!=2){
			--i;
			break;
		}
		load =0;
		arr[i]=(int*)malloc(row[i]*col[i]*sizeof(int));

		for (int r=0; r<row[i]*col[i]; ++r){
			if(scanf("%i", &arr[i][r])!=1){
				fprintf(stderr, "Error: Chybny vstup!\n");
				return 100;
			}
		}
		scanf("%c%c", &operator[i], &operator[i]); //nacte operator (musi nejdriv zahodit konec radku, potom az vlastni operator)
	}

	//multiply
	for(int j=0; j<i; j++){
		if (operator[j]=='*'){
			if (row[j+1] == col[j]){  //kontrola jestli matice vubec jde vynasobit
				matrix_multiply(j, row, col, arr); // posle do matrix_multiply
				operator[j]='+';
			}
			else{
				fprintf(stderr, "Error: Chybny vstup!\n");
				return 100;
			}
		}
	}

	//plus and minus
	for(j=0; j<i; ++j){
	//secte/odecte pokud jde (tota verye matici a jeji nasledujici - vlastni problem
		if(j>0 && (row[j]!=row[j+1] || col[j]!=col[j+1])){
			fprintf(stderr, "Error: Chybny vstup!\n");
//			return 100;
		}
		if(operator[j]=='-'){
			for (int k = 0; k<row[j]*col[j]; ++k)
				arr[j+1][k]=arr[j][k]-arr[j+1][k];
		}

		if(operator[j]=='+'){
			for (int k = 0; k<row[j]*col[j]; ++k)
				arr[j+1][k]=arr[j][k]+arr[j+1][k];
		}
	}

/* plus[minus vol 2... pocita s vynulovanim col[] v matix_multiply

	for(j=0; col[j]==0; ++j); 	//najde prvni nenulovy prvek
	for(;j<i; j = j+h){ 		//nakonci j preskoci na prvek se kterym se porovnaval
		h=1;
		while(col[j+h]==0) 	//j+h je dalsi nenulovz prvek po j
			++h;
	praktivcky stejne jak vol.1 ale misto j+1 je j+h

	toto umi vyresit problem s kontrolou, ale neumi pocitat / nejspis spatne indexy pole a uz mi z toho hrabe

*/

	//printing result
	printf("%i %i\n", row[j], col[j]);
	for (int k = 0; k<col[j]*row[j];++k){
			if((k+1)%col[j]==0){
				printf("%i\n", arr[j][k]);
			}
			else{
				printf("%i ", arr[j][k]);
			}

	}
/*	for(int bla = 0; bla < i; ++bla){
		printf("%i", col[bla]);
		free(arr[bla]);
	}*/
	free(arr);
}

void matrix_multiply(int position, int *row, int *col, int **arr){
//vlastni nasobeni funguje, ver tomu

	int rA = row[position];
	int cA = col[position];
	int cB = col[position +1];
	int nb =0;
	int schwein=0;

	int *result = (int*)malloc(rA*cB*sizeof(int));

	for(int m=0; m<rA; ++m){
		for(int p=0; p<cB; ++p){
			for(int i=0; i<cA; ++i){
				nb = nb+arr[position][m*cA+i]*arr[position+1][i*cB+p];
			}
		result[schwein]= nb;
		nb=0;
		++schwein;
		}
	}

	arr[position]=(int*)realloc(arr[position], rA*cB*sizeof(int)); 		// zmena velikosti  v pameti obou matic na vyslednou matici (kvuli scitani bey core dumped
	arr[position+1]=(int*)realloc(arr[position+1], rA*cB*sizeof(int));

	for (int i=0; i<rA*cB; ++i){
		arr[position][i]=result[i];	//vytiskne vysledek nasobeni do LEVE matice
		arr[position+1][i]=0;		//vytiskne do prave matice 0000000
	}
/*tady zacina problem.. zmeni ulozenou velikost obou matic, aby prosly kontrolou pri scitani.. nicmene..
pokud nasobis vic matic za sebou / napr rozmerech 4*4, 4*3, 3*2, pak vysledna matice je 4*2, col[position] je 3 -> neprojde kontrolou rozmeru pri scitani*/
	row[position+1]=rA;
	col[position]=cB;
	free(result);
/*co me napadlo tak udelat
col[result = 0];

a pri scitani rict "if col[]==0, "skip";*/
}