#include <bits/stdc++.h>
#include <experimental/type_traits>

// {{{ boilerplate

class Dsu : public std::vector<int> {
public:
  explicit Dsu(int n) : std::vector<int>(n, -1) {}

  int find(int u) {
    if ((*this)[u] == -1) {
      return u;
    }
    if ((*this)[u] != u) {
      (*this)[u] = find((*this)[u]);
    }
    return (*this)[u];
  }

  bool merge(int a, int b) {
    if (find(a) == find(b)) {
      return false;
    }
    (*this)[find(a)] = find(b);
    return true;
  }
};


// }}}

int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(0);
  std::cout.tie(0);
  int n, Q;
  while (std::cin >> n >> Q) {
    std::vector<std::tuple<int, int, int>> queries(Q);
    std::vector<int> count(n + 1);
    for (int i = 0, x, y, l; i < Q; i++) {
      std::cin >> x >> y >> l;
      queries[i] = {x - 1, y - 1, l};
      count[l]++;
    }
    for (int i = 1; i <= n; i++) {
      count[i] += count[i - 1];
    }
    std::vector<std::pair<int, int>> queue(Q);
    for (auto [x, y, l] : queries) {
      queue[--count[l]] = {x, y};
    }
    Dsu dsu(n);
    int rear{Q}, components{n};
    for (int l = n; l >= 1; l--) {
      auto head = count[l];
      for (int i = rear; i-- > head;) {
        auto [x, y] = queue[i];
        if (dsu.merge(x, y)) {
          components--;
          queue[i++] = queue[head];
          queue[head++] = {
              x + 1,
              y + 1,
          };
        }
      }
      rear = head;
    }
    int result{1};
    for (int _ = 0; _ < components; _++) {
      result = 26LL * result % 1'000'000'007;
    }
    std::cout << result << '\n';
  }
}