import java.lang.*;

class MP26
{
	public static void main (String[] args)
		throws java.lang.Exception
	{
		int[][] A={{1,0,0},{0,1,0},{0,0,1},{1,0,1}};
		int[][] B={{1,2},{3,4},{5,6}};
		int[][] C = Matrix.valueOf(A).multiply(Matrix.valueOf(B)).getArray();
		
		java.lang.System.out.println(Matrix.toString(C));
	}
	
	private static class Matrix
	{
		private final int[][] array;
		private final int row;
		private final int col;
		
		private Matrix (int[][] array)
		{
			this.array = array;
			this.row = array.length;
			this.col = array[0].length;
		}
		
		static boolean isMatrix (int[][] array)
		{
			if (array == null) 
			{
				return false;
			}
			
			int col = -1;
			for (int[] line : array)
			{
				if (line == null) 
				{
					return false;
				}
				
				if (col < 0)
				{
					col = line.length;
				}
				else if (col != line.length)
				{
					return false;
				}
			}
			
			if (col < 1)
			{
				return false;
			}
			
			return true;
		}
		
		Matrix multiply (Matrix B) throws MatrixException
		{
			if (B == null)
			{
				throw new NullArgumentException("B");
			}
			
			if (col != B.row)
			{
				throw new MatrixException("Unmatch size of B.row");
			}
			
			int[][] C = new int[row][B.col];
			for (int i = 0; i < row; ++i)
			{
				for (int j = 0; j < B.col; ++j)
				{
					for (int k = 0; k < col; ++k)
					{
						C[i][j] += array[i][k] * B.array[k][j];
					}
				}
			}
			return new Matrix(C);
		}
		
		int[][] getArray ()
		{
			return array.clone();
		}
		
		@Override
		public String toString ()
		{
			java.io.ByteArrayOutputStream buf 
				= new java.io.ByteArrayOutputStream();
			java.io.PrintStream out
				= new java.io.PrintStream(buf);
			
			for (int[] line : array)
			{
				for (int value : line)
				{
					out.print(value + " ");
				}
				out.println();
			}
			
			return buf.toString();
		}
		
		static String toString (int[][] array)
		{
			if (Matrix.isMatrix(array) == false)
			{
				throw new java.lang.IllegalArgumentException("array");	
			}
			return new Matrix(array).toString();
		}

		static Matrix valueOf (int[][] array)
		{
			if (Matrix.isMatrix(array) == false)
			{
				throw new java.lang.IllegalArgumentException("array");
			}
			return new Matrix(array.clone());
		}
	}

	private static class MatrixException
		extends java.lang.Exception
	{
		MatrixException (String message)
		{
			super(message);
		}
	}

	private static class NullArgumentException
		extends java.lang.IllegalArgumentException
	{
		NullArgumentException (String argname)
		{
			super(argname);
		}
	}
}