#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using ull = unsigned long long;
constexpr int N = 1e5 + 10;
constexpr int inf = 1e9 + 10;
constexpr ll llinf = 1e18 + 10;
constexpr int mod = 998244353;
void debug() {
    std::cerr << "\n";
}
template<typename T, typename... Args>
void debug(T val, const Args&... args) {
    std::cerr << val << " ";
    debug(args...);
}
template<typename T>
void debug(const std::vector<T>& vec) {
    for (const T& x : vec) std::cerr << x << ' ';std::cerr << "\n";
}
struct DSU
{
    std::vector<int> f, siz, d;

    DSU() {}
    DSU(int n)
    {
        build(n);
    }

    void build(int n)
    {
        f.resize(n + 1); d.resize(n + 1);
        std::iota(f.begin(), f.end(), 0);
        siz.assign(n + 1, 1);
    }

    int find(int x)
    {
        if (x != f[x]) {
            int px = find(f[x]);
            d[x] += d[f[x]];
            f[x] = px;
        }
        return f[x];
    }

    bool same(int x, int y)
    {
        return find(x) == find(y);
    }

    bool merge(int x, int y, int op = 1)
    {
        int px = find(x), py = find(y);
        if (px == py)
        {
            return false;
        }
        siz[py] += siz[px];
        f[px] = py;
        d[px] = d[y] - d[x] + op;//要确保d[px]>0
        return true;
    }

    int size(int x)
    {
        return siz[find(x)];
    }
    int dist(int x)
    {
        return d[x];
    }
};
void ncl3() {
    int n, m;
    std::cin >> n >> m;
    std::vector<std::vector<int>> er(n), eb(n);
    std::vector<std::array<int, 3>> edges(m);
    std::vector<int> dr(n), db(n);
    DSU S(n), dsu(n);
    for (auto& [u, v, c] : edges) {
        std::cin >> u >> v >> c;
        u--, v--;
        if (c == 0)
            S.merge(u, v);
    }
    for (auto [u, v, c] : edges) {
        if (c == 1 && S.same(u, v)) {
            dsu.merge(u, v);
        }
    }
    for (auto [u, v, c] : edges) {
        if (c == 0 && dsu.same(u, v)) {
            // debug(u, v, dsu.find(u), dsu.find(v), c);
            er[u].push_back(v);
            er[v].push_back(u);
            dr[u]++, dr[v]++;
        }
        if (c == 1 && dsu.same(u, v)) {
            eb[u].push_back(v);
            eb[v].push_back(u);
            db[u]++, db[v]++;
        }
    }
    ll ans = n;
    std::vector<int> cnt(n);
    for (int u = 0; u < n; u++) {
        // assert(dsu.size(u) <= 4);
        if (dsu.size(u) == 4) {
            int v = -1;
            for (auto v1 : er[u]) {
                for (auto v2 : eb[u]) {
                    if (v1 == v2) {
                        v = v1;
                    }
                }
            }
            // debug(u, v);
            if (v != -1 && u < v) {
                ans++;
            }
        }
    }

    for (int i = 0; i < n; i++) {
        // if (dsu.find(i) == 3) debug(i, dr[i], db[i]);
        if (dsu.find(i) == i) {
            if (dsu.size(i) == 2) ans++;
            if (dsu.size(i) == 4) ans++;
            if (dsu.size(i) == 3) ans += 2;
        }
    }
    std::cout << ans % mod << "\n";
}
/*
    预处理、找性质缩小范围、集合思想、正难则反、穷举
*/
int main() {
#ifdef LOCAL
    clock_t time = clock();
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    int t = 1;
    // std::cin >> t;
    while (t--) {
        ncl3();
    }
#ifdef LOCAL
    std::cout << "Time Used:" << clock() - time << "ms" << "\n";
#endif
    return 0;
}