#include <algorithm>
#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <iostream>
#include <numeric>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <functional>
#include <iomanip>
using namespace std;
using ll = long long;

class range {private: struct I{int x;int operator*(){return x;}bool operator!=(I& lhs){return x<lhs.x;}void operator++(){++x;}};I i,n;
public:range(int n_):i({0}),n({n_}){}range(int i_,int n_):i({i_}),n({n_}){}I& begin(){return i;}I& end(){return n;}};

template<typename T, typename U> ostream& operator<<(ostream& os, const pair<T, U>& p){ return os << "{" << p.first << ", " << p.second << "}"; }
template<typename T> ostream& operator<<(ostream& os, const vector<T>& obj) { os << "{"; for (const auto& e : obj) os << e << ", "; return os << "}"; }
template<typename T> ostream& operator<<(ostream& os, const set<T>& obj) { os << "set{"; for (const auto& e : obj) os << e << ", "; return os << "}"; }
template<typename T, typename U> ostream& operator<<(ostream& os, const map<T, U>& obj) { os << "map{"; for (const auto& e : obj) os << e << ", "; return os << "}"; }

#ifdef ONLINE_JUDGE
#define dump(expr) ;
#else
#define dump(expr) { cerr << "\033[33m#L" << __LINE__ << ": " << expr << "\033[39m" << endl; }
#endif

const ll mod = 1000000007;
struct mint {
  ll x;
  mint(ll x_ = 0) : x((x_ % mod + mod) % mod) {}
  mint operator-() const { return mint(-x); }
  mint &operator+=(const mint &a) { if ((x += a.x) >= mod) x -= mod; return *this; }
  mint &operator-=(const mint &a) { if ((x += mod - a.x) >= mod) x -= mod; return *this; }
  mint &operator*=(const mint &a) { (x *= a.x) %= mod; return *this; }
  mint operator+(const mint &a) const { mint res(*this); return res += a; }
  mint operator-(const mint &a) const { mint res(*this); return res -= a; }
  mint operator*(const mint &a) const { mint res(*this); return res *= a; }
  mint pow(ll t) const { if (!t) return 1; mint a = pow(t >> 1); a *= a; if (t & 1) a *= *this; return a; }
  mint inv() const { return pow(mod - 2); }
  mint &operator/=(const mint &a) { return (*this) *= a.inv(); }
  mint operator/(const mint &a) const { mint res(*this); return res /= a; }
  friend ostream &operator<<(ostream &os, const mint &m) { os << m.x; return os; }
  friend istream &operator>>(istream &is, mint &m) { is >> m.x; return is; }
};

using Field = mint;
typedef vector<mint> Vec;
typedef vector<Vec> Mat;

Mat mul(Mat mat1, Mat mat2) {
  int h = mat1.size(), in = mat1[0].size(), w = mat2[0].size();
  assert((int)mat2.size() == in);

  Mat ret(h, Vec(w, 0));
  for (int y : range(h)) for (int x : range(w)) for (int i : range(in)) {
    ret[y][x] += mat1[y][i] * mat2[i][x];
  }

  return ret;
}

Mat pow(Mat mat, ll power) {
  int n = mat.size();

  Mat ret(n, Vec(n, 0));
  for (int i : range(n)) ret[i][i] = 1;

  while (power > 0) {
    if (power & 1)
      ret = mul(ret, mat);
    mat = mul(mat, mat);
    power >>= 1;
  }
  return ret;
}

namespace solver {

ll k, m, n;
vector<ll> ps, qs, rs;

void read() {
  cin >> k >> m >> n;
  ps.resize(m);
  qs.resize(m);
  rs.resize(m);
  for (int i : range(m)) {
    cin >> ps[i] >> qs[i] >> rs[i];
  }
}

using RetType = mint;

RetType run() {
  Mat A(k * k, Vec(k * k, 0));

  for (int i : range(m)) {
    int p = ps[i], q = qs[i], r = rs[i];
    p--; q--; r--;
    assert(0 <= p && p < k);
    assert(0 <= q && q < k);
    assert(0 <= r && r < k);
    A[p * k + q][q * k + r] = 1;
  }
  Mat P = pow(A, n - 2);
  dump(P)
  mint res;

  for (int i : range(k * k)) if (i / k == 0)
  for (int j : range(k * k)) if (j % k == 0) {
    res += P[i][j];
  }
  return res;
}

}  // namespace

template <typename F>
void run(F f) { if constexpr (std::is_same_v<decltype(f()), void>) f(); else cout << f() << endl; }

int main(int argc, char** argv) {
  cerr << fixed << setprecision(12);
  cout << fixed << setprecision(12);
  int testcase = 1;
  if (argc > 1) testcase = atoi(argv[1]);
  while (testcase--) {
    solver::read();
  }
  run(solver::run);
}