using System;
using System.Collections.Generic;
using System.Text;

namespace AOJ
{
    class Program
    {
        struct Matrix
        {
            long[] values;
            int nrow;
            int ncol;

            public Matrix(int nrow, int ncol)
            {
                this.nrow = nrow;
                this.ncol = ncol;
                values = new long[nrow * ncol];
            }

            public int row { get { return nrow; } }
            public int col { get { return ncol; } }
            public long this[int irow, int icol]
            {
                get { return values[ncol * irow + icol]; }
                set { values[ncol * irow + icol] = value; }
            }
        }

        static Matrix Multiply(ref Matrix lhs, ref Matrix rhs)
        {
            if (lhs.col != rhs.row)
            {
                throw new Exception();
            }

            var nmix = lhs.col;

            var result = new Matrix(lhs.row, rhs.col);
            for (int irow = 0; irow < result.row; ++irow)
            {
                for (int icol = 0; icol < result.col; ++icol)
                {
                    long sum = 0;
                    for (int imix = 0; imix < nmix; ++imix)
                    {
                        sum += lhs[irow, imix] * rhs[imix, icol];
                    }
                    result[irow, icol] = sum;
                }
            }

            return result;
        }

        static bool LoadFromStdin(int nrow, int ncol, out Matrix matrix)
        {
            matrix = new Matrix(nrow, ncol);

            for (int irow = 0; irow < nrow; ++irow)
            {
                var inputLine = Console.In.ReadLine();
                var inputs = inputLine.Split(new char[] { ' ', '\t', '　' });
                if (inputs.Length != ncol)
                {
                    return  false;
                }
                for (int icol = 0; icol < ncol; ++icol)
                {
                    matrix[irow, icol] = int.Parse(inputs[icol]);
                }
            }

            return true;
        }

        static void Main(string[] args)
        {
            var firstInputLine = Console.In.ReadLine();
            var firstInputs = firstInputLine.Split(new char[] { ' ', '\t', '　' });

            var nrow = int.Parse(firstInputs[0]);
            var nmix = int.Parse(firstInputs[1]);
            var ncol = int.Parse(firstInputs[2]);

            Matrix matrix0, matrix1;

            if(LoadFromStdin(nrow, nmix, out matrix0) == false)
            {
                return;
            }
            if(LoadFromStdin(nmix, ncol, out matrix1) == false)
            {
                return;
            }

            var result = Multiply(ref matrix0, ref matrix1);

            var outputIntegers = new long[result.col];
            for (int irow = 0; irow < result.row; ++irow)
            {
                for (int icol = 0; icol < result.col; ++icol)
                {
                    outputIntegers[icol] = result[irow, icol];
                }
                var outputLine = string.Join(" ", outputIntegers);
                Console.WriteLine(outputLine);
            }
        }
    }
}



Measured memory_bytes: 20048