#include<bits/stdc++.h>
using namespace std;
using ll=long long;
using ld=long double;
using pii=pair<ll,ll>;
#define x first
#define y second
#define IOS ios::sync_with_stdio(false),cin.tie(0),cout.tie(0)
#define rep(i, a, b) for(ll i = (a); i <= (b); i++)
constexpr ll mod=1e9+7,INF=1e18,N=2e5+10;
constexpr ld eps=1e-5;

ll n,m;
vector<pii> g[N];
bool st[N],md[N];

struct Graph{
    vector<ll> Node;
    bool operator<(const Graph &x) const{
        return Node<x.Node;
    }

    void dfs(ll u,ll fa,ll op){
        st[u]=1;
        for(auto x:g[u]){
            ll v=x.first,c=x.second;
            if(c!=op||!md[v]) continue;
            if(v==fa) continue;
            dfs(v,u,op);
        }
    }

    bool check(){
        bool f=1;
        for(auto x:Node) st[x]=0,md[x]=1;
        
        dfs(Node[0],0,0);
        for(auto x:Node){
            if(!st[x]){
                f=0;
                break;
            }
        }
        for(auto x:Node) st[x]=0;
        dfs(Node[0],0,1);

        for(auto x:Node){
            if(!st[x]){
                f=0;
                break;
            }
        }

        for(auto x:Node) md[x]=0;
        // if(f){
        //     for(auto x:Node) cout<<x<<' ';
        //     cout<<'\n';
        // }
        return f;
    }
};

set<Graph> q;


void cal(ll u){
    vector<ll> Node;

    for(auto x:g[u]){
        Node.push_back(x.first);
    }
    sort(Node.begin(),Node.end());
    Node.erase(unique(Node.begin(),Node.end()),Node.end());

    Graph G;
    if(Node.size()==1){
        G.Node.clear();
        G.Node.push_back(u),G.Node.push_back(Node[0]);
        sort(G.Node.begin(),G.Node.end());
        q.insert(G);
    }else if(Node.size()==2){
        G.Node.clear();
        G.Node.push_back(u),G.Node.push_back(Node[0]);
        sort(G.Node.begin(),G.Node.end());
        q.insert(G);
        G.Node.clear();
        G.Node.push_back(u),G.Node.push_back(Node[1]);
        sort(G.Node.begin(),G.Node.end());
        q.insert(G);
        G.Node.clear();
        G.Node.push_back(u),G.Node.push_back(Node[0]),G.Node.push_back(Node[1]);
        sort(G.Node.begin(),G.Node.end());
        q.insert(G);
    }else if(Node.size()==3){
        G.Node.clear();
        G.Node.push_back(u),G.Node.push_back(Node[0]);
        sort(G.Node.begin(),G.Node.end());
        q.insert(G);
        G.Node.clear();
        G.Node.push_back(u),G.Node.push_back(Node[1]);
        sort(G.Node.begin(),G.Node.end());
        q.insert(G);
        G.Node.clear();
        G.Node.push_back(u),G.Node.push_back(Node[2]);
        sort(G.Node.begin(),G.Node.end());
        q.insert(G);
        G.Node.clear();
        G.Node.push_back(u),G.Node.push_back(Node[0]),G.Node.push_back(Node[1]);
        sort(G.Node.begin(),G.Node.end());
        q.insert(G);
        G.Node.clear();
        G.Node.push_back(u),G.Node.push_back(Node[0]),G.Node.push_back(Node[2]);
        sort(G.Node.begin(),G.Node.end());
        q.insert(G);
        G.Node.clear();
        G.Node.push_back(u),G.Node.push_back(Node[1]),G.Node.push_back(Node[2]);
        sort(G.Node.begin(),G.Node.end());
        q.insert(G);
        G.Node.clear();
        G.Node.push_back(u),G.Node.push_back(Node[0]),G.Node.push_back(Node[1]),G.Node.push_back(Node[2]);
        sort(G.Node.begin(),G.Node.end());
        q.insert(G);
    }
}

void solve(){
    cin>>n>>m;
    ll u,v,w;
    for(int i=1;i<=m;i++){
        cin>>u>>v>>w;
        g[u].push_back({v,w}),g[v].push_back({u,w});
    }

    for(int i=1;i<=n;i++) cal(i);
    
    ll ans=n;
    for(auto x:q) ans+=x.check();
    cout<<ans<<'\n';
}


int main(){
    IOS;
    int t=1;
    //cin>>t;
    while(t--) solve();
    return 0;
}
/*
3 4
1 2 0
1 3 1
2 3 0
2 3 1

4 6
1 2 0
2 3 0
3 4 0
1 4 1
2 4 1
1 3 1

*/