/* Auteur: Nicolas JANEY          */
/* nicolas.janey@univ-fcomte.fr   */
/* Fevrier 2005                   */

import java.io.*;

public class PuissanceMatrice {
  static BufferedReader flux = new BufferedReader(new InputStreamReader(System.in));
  
  /* Fonction de recherche de la valeur                   */
  /* de absolue maximale d'une matrice                    */
  /* m : tableau d'entiers ou effectuer la recherche      */
  /* Resultat fonction : entier                           */

  public static int valAbsMax(int [][] m) {
    int ii = 0;
    int jj = 0;
    for ( int i = 0 ; i < m.length ; i++ ) {
      for ( int j = 0 ; j < m[0].length ; j++ ) {
      if ( Math.abs(m[i][j]) > Math.abs(m[ii][jj]) ) {
        ii = i;
        jj = j; } } }
    return(m[ii][jj]);
  }

  /* Fonction de creation d'une chaine de caracteres      */
  /* representant un nombre justifie a droite complemente */
  /* par des espaces                                      */
  /* v : entier a formater                                */
  /* larg : nombre de caracteres de la chaine resultat    */
  /* Resultat fonction : Chaine de caracteres             */

  public static String justifieADroite(int v,int larg) {
  /* Definition et initialisation de la chaine            */
  /* avec l'entier a formater                             */
    String s = ""+v;
  /* Ajout a gauche a la chaine d'autant de caracteres    */
  /* espace qu'il le faut pour que sa longueur devienne   */
  /* superieure ou egale a la largeur recherchee          */
    while ( s.length() < larg )
      s = " "+s;
  /* Resultat de la fonction                              */
    return(s);
  }

  /* Fonction d'affichage d'une matrice d'entiers         */
  /* m : tableau d'entiers a afficher                     */
  /* larg : largeur de chaque colonne                     */

  public static void affichageMatrice(int [][] m) {
    int max = valAbsMax(m);
    int larg = 1+((""+max).length());
    for ( int i = 0 ; i < m.length ; i++ ) {
  /* Pour toute les lignes de la matrice a afficher       */
      for ( int j = 0 ; j < m[0].length ; j++ ) {
  /* Affichage d'un entier de la ligne i                  */
  /* (sans aller a la ligne                               */
        System.out.print(justifieADroite(m[i][j],larg+1)); }
  /* On va a la ligne quand tous les entiers d'une ligne  */
  /* ont ete affiches                                     */
      System.out.println(); }
  }

  /* Fonction de creation d'une matrice carree d'entiers  */
  /* initialisee avec des nombres aleatoires              */
  /* n : nombres de lignes et de colonnes de la matrice   */
  /* max : valeur maximale des nombres aleatoires         */
  /* Resultat fonction : Matrice d'entiers                */

  public static int [][] creationMatriceAleatoire(int n,int max) {
  /* Allocation de la matrice                             */
    int [][] m = new int[n][n];
  /* Pour toutes les lignes de la matrice a initialiser   */                                    
    for ( int i = 0 ; i < n ; i++ )
  /* Pour toutes les colonnes de la matrice a initialiser */
      for ( int j = 0 ; j < n ; j++ ) {
  /* Initialisation avec un nombre aleatoire compris      */
  /* entre 0 et max                                       */
        m[i][j] =(int) (Math.random()*(max+1))-max/2; }
  /* Resultat de la fonction                              */
    return(m);
  }

  /* Fonction de creation de la copie d'une matrice       */
  /* d'entiers                                            */
  /* m : Matrice d'entiers a copier                       */
  /* Resultat fonction : Matrice d'entiers                */

  public static int [][] copieMatrice(int [][] src) {
  int l = src.length;
  int c = src[0].length;
  /* Allocation de la matrice                             */
    int [][] m = new int[l][c];
  /* Pour toutes les lignes de la matrice a initialiser   */                                    
    for ( int i = 0 ; i < l ; i++ )
  /* Pour toutes les colonnes de la matrice a initialiser */
      for ( int j = 0 ; j < c ; j++ ) {
  /* Copie de src dans m pour les valeurs d'indice (i,j)  */
        m[i][j] = src[i][j]; }
  /* Resultat de la fonction                              */
    return(m);
  }

  /* Fonction de calcul de la matrice produit             */
  /* de deux matrices carrees                             */
  /* m1,m2 : Tableau d'entiers                            */
  /* Resultat fonction : Tableau d'entiers                */

  public static int [][] produitMatriceMatrice(int [][] m1,int [][] m2) {
  /* Allocation de la matrice                             */
    int n = m1.length;
    int [][] m = new int[n][n];
  /* Pour toutes les lignes de la matrice a calculer      */                                    
    for ( int i = 0 ; i < n ; i++ )
  /* Pour toutes les colonnes de la matrice a calculer    */
      for ( int j = 0 ; j < n ; j++ ) {
  /* Produit ligne par colonne                            */
        m[i][j] = 0;
        for ( int k = 0 ; k < n ; k++ )
          m[i][j] += m1[i][k]*m2[k][j]; }
  /* Resultat de la fonction                              */
    return(m);
  }

  /* Fonction de calcul de la matrice a la puissance p    */
  /* d'une matrice carree                                 */
  /* m : Tableau d'entiers                                */
  /* p : entier                                           */
  /* Resultat fonction : Tableau d'entiers                */

  public static int [][] matricePuissance(int [][] m,int p) {
  /* Si p est egal a 1, une copie de m est creee          */
  /* et retournee                                         */
    if ( p == 1 )
      return(copieMatrice(m));
  /* Si p n'est egal a 1 (superieur), un tableau t        */
  /* est declare pour accueillir le produit de m par m    */
    int [][] t = produitMatriceMatrice(m,m);
  /* Une boucle pour permet d'accumuler dans t            */
  /* tous les produits t par m necessaires au calcul      */
  /* final de m a la puissance p                          */
    for ( int i = 2 ; i < p ; i++ )
      t = produitMatriceMatrice(t,m);
  /* Resultat de la fonction                              */
    return(t);
  }

  /* Fonction principale                                  */

  public static void main(String [] args) throws IOException {
  /* Lecture au clavier de la taille de la matrice        */
    System.out.print("Taille de la matrice : ");
    int n = Integer.valueOf(flux.readLine()).intValue();
  /* Lecture au clavier de la puissance desiree           */
    System.out.print("A quelle puissance   : ");
    int p = Integer.valueOf(flux.readLine()).intValue();
  /* Creation d'une matrice de n sur n entiers aleatoires */
    int [][] m = creationMatriceAleatoire(n,10);
  /* Affichage de ma matice m                             */
    System.out.println("La matrice est :");
    affichageMatrice(m);
  /* Creation de la matrice m a la puissance p            */
    int [][] mp = matricePuissance(m,p);
  /* Affichage du resultat du remplissage                 */
    System.out.println("m^p :");
    affichageMatrice(mp);
  }
}