#include <algorithm>
#include <cassert>
#include <cctype>
#include <chrono>
#define _USE_MATH_DEFINES
#include <cmath>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;

#define FOR(i,m,n) for(int i=(m);i<(n);++i)
#define REP(i,n) FOR(i,0,n)
#define ALL(v) (v).begin(),(v).end()

const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3fLL;
const int MOD = 1000000007; // 998244353
const int dy[] = {1, 0, -1, 0}, dx[] = {0, -1, 0, 1};
/*-------------------------------------------------*/
struct UnionFind {
  UnionFind(int sz) : data(sz, -1) {}

  int root(int ver) { return data[ver] < 0 ? ver : data[ver] = root(data[ver]); }

  void unite(int ver1, int ver2) {
    ver1 = root(ver1);
    ver2 = root(ver2);
    if (ver1 != ver2) {
      if (data[ver1] > data[ver2]) swap(ver1, ver2);
      data[ver1] += data[ver2];
      data[ver2] = ver1;
    }
  }

  bool same(int ver1, int ver2) { return root(ver1) == root(ver2); }

  int size(int ver) { return -data[root(ver)]; }

private:
  vector<int> data;
};

using CostType = long long;
struct Edge {
  int src, dst;
  CostType cost;
  Edge(int src_, int dst_, CostType cost_ = 0) : src(src_), dst(dst_), cost(cost_) {}
  inline bool operator<(const Edge &rhs) const {
    return cost != rhs.cost ? cost < rhs.cost : dst != rhs.dst ? dst < rhs.dst : src < rhs.src;
  }
  inline bool operator<=(const Edge &rhs) const { return cost <= rhs.cost; }
  inline bool operator>(const Edge &rhs) const {
    return cost != rhs.cost ? cost > rhs.cost : dst != rhs.dst ? dst > rhs.dst : src > rhs.src;
  }
  inline bool operator>=(const Edge &rhs) const { return cost >= rhs.cost; }
};

CostType kruskal(const vector<vector<Edge> > &graph, const Edge e) {
  int sz = graph.size();
  priority_queue<Edge, vector<Edge>, greater<Edge> > que;
  REP(i, sz) for (Edge e : graph[i]) que.emplace(e);
  CostType total = e.cost;
  UnionFind uf(sz);
  uf.unite(e.src, e.dst);
  while (!que.empty()) {
    Edge e = que.top(); que.pop();
    if (!uf.same(e.src, e.dst)) {
      total += e.cost;
      uf.unite(e.src, e.dst);
    }
  }
  return total;
}

int main() {
  cin.tie(0); ios::sync_with_stdio(false);
  // freopen("input.txt", "r", stdin);

  int n, m; long long x; cin >> n >> m >> x;
  vector<vector<Edge> > graph(n);
  vector<Edge> edge;
  REP(i, m) {
    int u, v, w; cin >> u >> v >> w; --u; --v;
    edge.emplace_back(Edge(u, v, w));
    graph[u].emplace_back(Edge(u, v, w));
    graph[v].emplace_back(Edge(v, u, w));
  }
  // その辺を必ず使ったときに最小全域木のコストが
  // (x 未満, x 以下) となる辺の個数
  int batsu = 0, maru = 0;
  REP(i, m) {
    // i 本目の辺を必ず使う場合の最小全域木のコスト
    long long mst = kruskal(graph, edge[i]);
    if (mst < x) ++batsu;
    if (mst <= x) ++maru;
  }
  // f(a) を最小全域木のコストが a 以下とはならない塗り方の総数とする
  // (ただし, 必ず最小全域木が構成できるとは限らない)
  // そういったものは mst の値が a 以下の辺はすべて同じ色となっている
  // mst <= a となる辺の本数を e とすると
  // (i) e = 0 のとき
  //   どのように塗ってもよいので f(a) = 2^m
  // (ii) e > 0 のとき
  //   mst <= a となる辺の塗り方は白と黒の2通り
  //   残りの辺はどのように塗ってもよいので f(a) = 2 * 2^(m-e)
  // 求める場合の数は f(x-1) - f(x)
  long long f_x_1 = 1, f_x = 1;
  if (batsu == 0) REP(i, m) (f_x_1 *= 2) %= MOD;
  else REP(i, m - batsu + 1) (f_x_1 *= 2) %= MOD;
  if (maru == 0) REP(i, m) (f_x *= 2) %= MOD;
  else REP(i, m - maru + 1) (f_x *= 2) %= MOD;
  long long ans = ((f_x_1 - f_x) % MOD + MOD) % MOD;
  cout << ans << '\n';
  return 0;
}


Measured memory_bytes: 512