#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


// !!!Modifies ns and edges!!!
// n: modified regular bipartite graph
// d := max degree = edge chromatic number
// iss[c]: edges of color c \in [0, d)
// colors[i]: color of edge i
struct BipartiteEdgeColoring {
  int ns[2];
  vector<pair<int, int>> edges;
  int n;
  int d;
  vector<int> colors;
  vector<vector<int>> iss;
  BipartiteEdgeColoring() {}
  BipartiteEdgeColoring(int n0, int n1) : ns{n0, n1}, edges() {}
  void ae(int u, int v) {
    assert(0 <= u); assert(u < ns[0]);
    assert(0 <= v); assert(v < ns[1]);
    edges.emplace_back(u, v);
  }
  void run() {
    const int m = edges.size();
    vector<int> deg[2];
    for (int s = 0; s < 2; ++s) deg[s].assign(ns[s], 0);
    for (const auto &edge : edges) {
      ++deg[0][edge.first];
      ++deg[1][edge.second];
    }
    d = 0;
    for (int s = 0; s < 2; ++s) for (int u = 0; u < ns[s]; ++u) if (d < deg[s][u]) d = deg[s][u];
    // Merge vertices of small degree.
    for (int s = 0; s < 2; ++s) {
      priority_queue<pair<int, int>, vector<pair<int, int>>, std::greater<pair<int, int>>> que;
      par.resize(ns[s]);
      for (int u = 0; u < ns[s]; ++u) que.emplace(deg[s][u], par[u] = u);
      for (; ; ) {
        if (!que.size()) break;
        const auto p0 = que.top(); que.pop();
        if (!que.size()) break;
        const auto p1 = que.top(); que.pop();
        if (p0.first + p1.first > d) break;
        par[p0.second] = p1.second;
        que.emplace(p0.first + p1.first, p1.second);
      }
      int nn = 0;
      vector<int> ids(ns[s], -1);
      for (int u = 0; u < ns[s]; ++u) if (par[u] == u) ids[u] = nn++;
      ns[s] = nn;
      if (s == 0) {
        for (auto &edge : edges) edge.first = ids[root(edge.first)];
      } else {
        for (auto &edge : edges) edge.second = ids[root(edge.second)];
      }
    }
    // Add edges to make the graph d-regular.
    n = max(ns[0], ns[1]);
    for (int s = 0; s < 2; ++s) deg[s].assign(n, 0);
    for (const auto &edge : edges) {
      ++deg[0][edge.first];
      ++deg[1][edge.second];
    }
    for (int u = 0, v = 0; ; ) {
      for (; u < n && deg[0][u] >= d; ++u) {}
      for (; v < n && deg[1][v] >= d; ++v) {}
      if (u == n && v == n) break;
      edges.emplace_back(u, v);
      ++deg[0][u];
      ++deg[1][v];
    }
    iss.clear();
    vector<int> is(n * d);
    for (int i = 0; i < n * d; ++i) is[i] = i;
    rec(is);
    // Remove added edges.
    colors.assign(m, -1);
    for (int k = 0; k < d; ++k) {
      iss[k].erase(std::lower_bound(iss[k].begin(), iss[k].end(), m), iss[k].end());
      for (const int i : iss[k]) colors[i] = k;
    }
  }
  vector<int> par;
  int root(int u) {
    return (par[u] == u) ? u : (par[u] = root(par[u]));
  }
  // is: k-regular
  void rec(vector<int> is) {
    if (!is.size()) return;
    const int k = is.size() / n;
    if (k == 1) {
      std::sort(is.begin(), is.end());
      iss.push_back(is);
    } else if (k % 2 != 0) {
      if (iss.size()) {
        is.insert(is.end(), iss.back().begin(), iss.back().end());
        iss.pop_back();
        rec(is);
      } else {
        // Add (2^e - k) bad matchings to find a perfect matching.
        const int e = (31 - __builtin_clz(k)) + 1;
        vector<int> ma(n);
        for (int u = 0; u < n; ++u) ma[u] = ~u;
        for (; ; ) {
          auto js = is;
          for (const int j : ma) for (int l = 0; l < (1 << e) - k; ++l) js.push_back(j);
          for (int f = e; --f >= 0; ) {
            const auto jss = euler(js);
            int numBads[2] = {};
            for (int s = 0; s < 2; ++s) for (const int i : jss[s]) if (i < 0) ++numBads[s];
            js = jss[(numBads[0] <= numBads[1]) ? 0 : 1];
          }
          ma.swap(js);
          bool good = true;
          for (const int j : ma) if (j < 0) {
            good = false;
            break;
          }
          if (good) break;
        }
        std::sort(ma.begin(), ma.end());
        iss.push_back(ma);
        std::sort(is.begin(), is.end());
        vector<int> iis;
        auto it = ma.begin();
        for (const int i : is) {
          for (; it != ma.end() && *it < i; ++it) {}
          if (!(it != ma.end() && *it == i)) iis.push_back(i);
        }
        rec(iis);
      }
    } else {
      const auto jss = euler(is);
      for (int s = 0; s < 2; ++s) rec(jss[s]);
    }
  }
  // Take Eulerian circuit and take edges alternately.
  vector<vector<int>> euler(const vector<int> &is) {
    const int isLen = is.size();
    vector<int> used(isLen, 0);
    vector<vector<pair<int, int>>> graph(n + n);
    for (int x = 0; x < isLen; ++x) {
      const int i = is[x];
      int u, v;
      if (i >= 0) {
        u = edges[i].first;
        v = n + edges[i].second;
      } else {
        u = ~i;
        v = n + ~i;
      }
      graph[u].emplace_back(x, v);
      graph[v].emplace_back(x, u);
    }
    vector<vector<int>> jss(2);
    int side = 0;
    vector<int> stack;
    for (int u0 = 0; u0 < n; ++u0) {
      for (stack.push_back(u0); stack.size(); ) {
        const int u = stack.back();
        if (graph[u].size()) {
          const int x = graph[u].back().first;
          const int v = graph[u].back().second;
          graph[u].pop_back();
          if (!used[x]) {
            used[x] = 1;
            jss[side].push_back(is[x]);
            side ^= 1;
            stack.push_back(v);
          }
        } else {
          stack.pop_back();
        }
      }
    }
    return jss;
  }
};

////////////////////////////////////////////////////////////////////////////////


int N, M, K;
vector<int> A, B;
vector<vector<int>> C;




int main() {
  for (; ~scanf("%d%d%d", &N, &M, &K); ) {
    A.resize(M);
    B.resize(M);
    C.assign(M, vector<int>(K));
    for (int i = 0; i < M; ++i) {
      scanf("%d%d", &A[i], &B[i]);
      --A[i];
      --B[i];
      for (int k = 0; k < K; ++k) {
        scanf("%d", &C[i][k]);
      }
    }
    
    BipartiteEdgeColoring bec(N, N);
    for (int i = 0; i < M; ++i) {
      bec.ae(A[i], B[i]);
    }
    bec.run();
    const auto &colors = bec.colors;
// cerr<<"colors = "<<colors<<endl;
    
    int limC = 0;
    for (int i = 0; i < M; ++i) {
      for (int k = 0; k < K; ++k) {
        chmax(limC, C[i][k]);
      }
    }
    ++limC;
    vector<vector<int>> iss(limC);
    for (int i = 0; i < M; ++i) {
      for (int k = 0; k < K; ++k) {
        iss[C[i][k]].push_back(i);
      }
    }
    
    vector<int> ans(M, -1);
    vector<int> sa(N, -1), sb(N, -1);
    for (int c = 0; c < limC; ++c) if (iss[c].size()) {
      /*
        stable matching
        left: prefer large color
        right: prefer small color
      */
      vector<int> as, bs;
      for (const int i : iss[c]) if (!~ans[i]) {
        as.push_back(A[i]);
        bs.push_back(B[i]);
      }
      sort(as.begin(), as.end()); as.erase(unique(as.begin(), as.end()), as.end());
      sort(bs.begin(), bs.end()); bs.erase(unique(bs.begin(), bs.end()), bs.end());
      const int asLen = as.size();
      const int bsLen = bs.size();
      for (int x = 0; x < asLen; ++x) sa[as[x]] = x;
      for (int y = 0; y < bsLen; ++y) sb[bs[y]] = y;
      vector<vector<int>> g(asLen);
      for (const int i : iss[c]) if (!~ans[i]) {
        g[sa[A[i]]].push_back(i);
      }
      for (int x = 0; x < asLen; ++x) {
        sort(g[x].begin(), g[x].end(), [&](int i0, int i1) -> bool {
          return (colors[i0] < colors[i1]);
        });
      }
      vector<int> isA(asLen, -1), isB(bsLen, -1);
      for (int x0 = 0; x0 < asLen; ++x0) {
        for (int x = x0; g[x].size(); ) {
          const int i = g[x].back();
          g[x].pop_back();
          if (~isB[sb[B[i]]]) {
            if (colors[isB[sb[B[i]]]] > colors[i]) {
              x = sa[A[isB[sb[B[i]]]]];
              isA[sa[A[i]]] = isB[sb[B[i]]] = i;
              isA[x] = -1;
            }
          } else {
            isA[sa[A[i]]] = isB[sb[B[i]]] = i;
            break;
          }
        }
      }
// cerr<<c<<": "<<isA<<" "<<isB<<endl;
      for (int x = 0; x < asLen; ++x) if (~isA[x]) {
        ans[isA[x]] = c;
      }
    }
    
    for (int i = 0; i < M; ++i) {
      if (i) printf(" ");
      printf("%d", ans[i]);
    }
    puts("");
  }
  return 0;
}