#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), cr(n), cb(n);
    for (auto& [u, v, c] : edges) {
        std::cin >> u >> v >> c;
        u--, v--;
        if (c == 0) {
            er[u].push_back(v);
            er[v].push_back(u);
            dr[u]++, dr[v]++;
        }
        if (c == 1) {
            eb[u].push_back(v);
            eb[v].push_back(u);
            db[u]++, db[v]++;
        }
    }
    ll ans = n;
    for (int u = 0; u < n; u++) {
        int v = -1;
        for (auto v1 : er[u]) {
            for (auto v2 : eb[u]) {
                if (v1 == v2) {
                    v = v1;
                }
            }
        }
        if (v != -1 && u < v) {
            ans++;
            for (auto v1 : er[u]) {
                if (v1 == v) continue;
                for (auto v2 : eb[v]) {
                    if (v2 == u) continue;
                    if (v1 == v2) {
                        ans++;
                    }
                }
            }
            for (auto v1 : eb[u]) {
                if (v1 == v) continue;
                for (auto v2 : er[v]) {
                    if (v2 == u) continue;
                    if (v1 == v2) {
                        ans++;
                    }
                }
            }
        }
    }
    DSU dsu(n);
    for (auto [u, v, c] : edges) {
        if ((dr[u] + db[u] == 3) && (dr[v] + db[v] == 3))
            dsu.merge(u, v);
    }
    std::vector<int> st(n);
    for (int i = 0; i < n; i++) {
        if (dsu.size(i) == 4) {
            int tr = 0, tb = 0;
            for (auto j : er[i]) {
                if(dsu.same(i, j))
                    tr++;
            }
            for (auto j : eb[i]) {
                if (dsu.same(i, j))
                    tb++;
            }
            int p = dsu.find(i);
            if(tr && tb) st[p]++;
            cr[p] += tr, cb[p] += tb;
        }
    }
    int t = 0;
    for (int i = 0; i < n; i++) {
        // debug(i, st[i], cr[i], cb[i]);
        if (st[i] == 4 && cr[i] == 6 && cb[i] == 6) {
            ans++;
            t++;
        }
    }
    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;
}