#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

const int MAXN = 100100;
vector<int> G[2][MAXN];

int timer[MAXN];
int par[MAXN];
int ttime = 0;

int get(int v) {
    if (v == par[v])
        return v;
    return par[v] = get(par[v]);
}

bool merge(int v, int u) {
    v = get(v);
    u = get(u);
    if (v == u)
        return false;
    par[v] = u;
    return true;
}

bool check_set(const vector<int>& vs) {
    ++ttime;
    for (int u : vs) {
        timer[u] = ttime;
    }
    for (int c = 0; c < 2; ++c) {
        for (int u : vs)
            par[u] = u;
        int comps = vs.size();
        for (int u : vs) {
            for (int v : G[c][u]) {
                if (timer[v] == ttime)
                    comps -= merge(v, u);
            }
        }
        if (comps != 1)
            return false;
    }
    return true;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    
    int n, m;
    cin >> n >> m;
    for (int i = 0; i < m; ++i) {
        int a, b, c;
        cin >> a >> b >> c;
        --a;
        --b;
        G[c][a].emplace_back(b);
        G[c][b].emplace_back(a);
    }
    int ans = n;
    vector<bool> is_good(n);
    for (int i = 0; i < n; ++i)
        is_good[i] = !G[0][i].empty() && !G[1][i].empty();
    vector<bool> was(n);
    vector<int> curr;
    for (int i = 0; i < n; ++i) {
        if (!is_good[i])
            continue;
        if (was[i])
            continue;
        vector<int> path;
        int cur = i;
        while (true) {
            path.emplace_back(cur);
            was[cur] = true;
            int to_next = -1;
            for (int nxt : G[0][cur]) {
                if (is_good[nxt] && !was[nxt]) {
                    to_next = nxt;
                    break;
                }
            }
            if (to_next == -1)
                break;
            cur = to_next;
        }
        bool is_cycle = false;
        for (int tmp : G[0][path.front()]) {
            if (tmp == path.back())
                is_cycle = true;
        }
        int look_mx = min(4, int(path.size() - 1));
        if (path.size() <= 4) {
            ans += check_set(path);
        }
        for (int j = 0; j < path.size(); ++j) {
            for (int l = 2; l <= look_mx; ++l) {
                if (j < l && !is_cycle)
                    continue;
                for (int k = 0; k < l; ++k)
                    curr.emplace_back(path[(j - k + path.size()) % path.size()]);
                ans += check_set(curr);
                curr.clear();
            }
        }
    }
    cout << ans << '\n';
    return 0;
}