#include <iostream>
#include <cassert>

class matrix
{
public:
        matrix(int N = 1, int M = 1)
        {
                width = M;
                length = N;
                values = new long long* [N];
                for (int i = 0; i < N; i++)
                {
                        values[i] = new long long[M];
                }
        }
        matrix(int N, int M, long long** arr)
        {
                width = M;
                length = N;
                values = arr;
        }

        matrix(const matrix& b)
        {
                width = b.width;
                length = b.length;
                values = new long long* [length];
                for (int i = 0; i < length; i++)
                {
                        values[i] = new long long[width];
                        for (int j = 0; j < width; j++)
                        {
                                values[i][j] = b.values[i][j];
                        }
                }
        }

        ~matrix()
        {
                for (int i = 0; i < length; i++)
                {
                        delete[] values[i];
                }
                delete[] values;
        }
        matrix& operator= (const matrix& b)
        {
                for (int i = 0; i < length; i++)
                {
                        delete[] values[i];
                }
                delete[] values;
                width = b.width;
                length = b.length;
                values = new long long* [length];
                for (int i = 0; i < length; i++)
                {
                        values[i] = new long long[width];
                        for (int j = 0; j < width; j++)
                        {
                                values[i][j] = b.values[i][j];
                        }
                }
                return *this;
        }
        const matrix operator* (const matrix& b)
        {
                assert(width == b.length);
                long long** newValues = new long long* [length];
                for (int i = 0; i < length; i++)
                {
                        newValues[i] = new long long[b.width];
                        for (int j = 0; j < b.width; j++)
                        {
                                long long result = 0;
                                for (int k = 0; k < width; k++)
                                {
                                        result += values[i][k] * b.values[k][j];
                                }
                                newValues[i][j] = result;
                        }
                }
                return matrix(length, width, newValues);
        }
        long long* operator[] (int i)
        {
                return values[i];
        }
private:
        int width;
        int length;
        long long** values;
};

matrix fastPowered(matrix x, long long y)
{
        if (y == 1)
        {
                return matrix(x);
        }
        if (y % 2 == 1)
        {
                return matrix(x * fastPowered(x * x, y / 2));
        }
        else
        {
                return matrix(fastPowered(x * x, y / 2));
        }
}

int main()
{
        int N;
        int d;
        std::cin >> N >> d;
        long long** values = new long long* [N];
        for (int i = 0; i < N; i++)
        {
                values[i] = new long long[N];
                for (int j = 0; j < N; j++)
                {
                        std::cin >> values[i][j];
                }
        }
        matrix M(N, N, values);
        M = fastPowered(M, d);
        for (int i = 0; i < N; i++)
        {
                for (int j = 0; j < N; j++)
                {
                        std::cout << M[i][j] << " ";
                }
                std::cout << "\n";
        }
}