// https://omegaup.com/arena/problem/Un-orden-para-todos
#include <algorithm>
#include <deque>
#include <climits>
#include <iostream>
#include <utility>
#include <vector>

struct intervalo {
   int izq, der;
};

struct grafica_flujo {
   std::vector<std::vector<int>> listas;
   std::vector<std::vector<int>> capacidad;
   int fuente, sumidero;

   grafica_flujo(int n, int f, int s)
   : listas(n), capacidad(n, std::vector<int>(n, 0)), fuente(f), sumidero(s) {
   }

   void agrega_arco(int v1, int v2, int c) {
      listas[v1].push_back(v2);
      listas[v2].push_back(v1);
      capacidad[v1][v2] = c;
   }

   int flujo_maximo( ) {
      int res = 0;
      for (;;) {
         auto [flujo, camino] = aumenta_flujo( );
         if (flujo == 0) {
            return res;
         }
         res += flujo;
         for (auto [v1, v2] : camino) {
            capacidad[v1][v2] -= flujo;
            capacidad[v2][v1] += flujo;
         }
      }
   }

   std::pair<int, std::vector<std::pair<int, int>>> aumenta_flujo( ) {
      std::deque<int> cola = { fuente };
      std::vector<int> distancia(listas.size( ), -1), previo(listas.size( ), -1);
      distancia[fuente] = 0;
      previo[fuente] = fuente;
      do {
         int procesar = cola.front( );
         cola.pop_front( );
         for (int v : listas[procesar]) {
            if (distancia[v] == -1 && capacidad[procesar][v] > 0) {
               distancia[v] = distancia[procesar] + 1;
               previo[v] = procesar;
               cola.push_back(v);
            }
         }
      } while (!cola.empty( ));

      if (distancia[sumidero] == -1) {
         return { 0, { } };
      } else {
         std::vector<std::pair<int, int>> camino;
         int flujo = INT_MAX, actual = sumidero;
         do {
            int anterior = previo[actual];
            camino.push_back({ anterior, actual });
            flujo = std::min(flujo, capacidad[anterior][actual]);
            actual = anterior;
         } while (actual != fuente);
         return { flujo, camino };
      }
   }
};

int main( ) {
   int n, p, d;
   std::cin >> n >> p >> d;

   int filas[p][n];
   for (int k = 0; k < p; ++k) {
      for (int j = 0; j < n; ++j) {
         std::cin >> filas[k][j];
      }
   }

   intervalo intervalos[n];
   for (int i = 0; i < n; ++i) {
      intervalos[i] = { 0, n - 1 };
   }
   for (int k = 0; k < p; ++k) {
      for (int j = 0; j < n; ++j) {
         int i = filas[k][j];
         intervalos[i] = { std::max(intervalos[i].izq, j - d), std::min(intervalos[i].der, j + d) };
      }
   }

   grafica_flujo g(2 * n + 2, 2 * n, 2 * n + 1);
   for (int i = 0; i < n; ++i) {
      g.agrega_arco(2 * n, i, 1);
   }
   for (int i = 0; i < n; ++i) {
      int izq = intervalos[i].izq;
      int der = intervalos[i].der;
      for (int j = izq; j <= der; ++j) {
         g.agrega_arco(i, j + n, 1);
      }
   }
   for (int j = 0; j < n; ++j) {
      g.agrega_arco(j + n, 2 * n + 1, 1);
   }

   int flujo = g.flujo_maximo( );
   if (flujo == n) {
      for (int j = 0; j < n; ++j) {
         for (int i = 0; i < n; ++i) {
            if (g.capacidad[j + n][i] == 1) {
               std::cout << i << " ";
            }
         }
      }
   } else {
      std::cout << -1;
   }
}