Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Matrix Multiplication

Write a program which reads a $n \times m$ matrix $A$ and a $m \times l$ matrix $B$, and prints their product, a $n \times l$ matrix $C$. An element of matrix $C$ is obtained by the following formula:

\[
c_{ij} = \sum_{k=1}^m a_{ik}b_{kj}
\]

where $a_{ij}$, $b_{ij}$ and $c_{ij}$ are elements of $A$, $B$ and $C$ respectively.

Input

In the first line, three integers $n$, $m$ and $l$ are given separated by space characters

In the following lines, the $n \times m$ matrix $A$ and the $m \times l$ matrix $B$ are given.

Output

Print elements of the $n \times l$ matrix $C$ ($c_{ij}$). Print a single space character between adjacent elements.

Constraints

$1 \leq n, m, l \leq 100$

$0 \leq a_{ij}, b_{ij} \leq 10000$

Sample Input

3 2 3
1 2
0 3
4 5
1 2 1
0 3 2

Sample Output

1 8 5
0 9 6
4 23 14

Note

      解説

Solution in C# (judge verdict: Accepted)

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);
            }
        }
    }
}