#include<set>

#include<map>

#include<queue>

#include<stack>

#include<cmath>

#include<cstdio>

#include<vector>

#include<bitset>

#include<cstring>

#include<iostream>

#include<algorithm>

#define ll long long

#define pr pair<int,int>

using namespace std;

int head[900];

int to[1800];

int val[1800];

int next[1800];

int dep[900];

int tot;

int f[900][12];

int g[900][12];

int n,m,k;

int u,v,w;

int id[900];

int now;

map<int,int>mp;

void add_edge(int u,int v,int w)

{

	next[++tot]=head[u];

	head[u]=tot;

	to[tot]=v;

	val[tot]=w;

}

namespace DINIC

{

	int tot=1;

	int S,T;

	int q[900];

	int d[900];

	int head[900];

	int next[18000];

	int val[18000];

	int col[900];

	int to[18000];

	int vir[18000];

	void add(int u,int v,int w)

	{

		next[++tot]=head[u];

		head[u]=tot;

		to[tot]=v;

		val[tot]=w;

		vir[tot]=w;

	}

	bool bfs(int S,int T)

	{

		int l=0,r=0;

		memset(d,-1,sizeof(d));

		q[r++]=S;

		d[S]=0;

		while(l<r)

		{

			int now=q[l];

			l++;

			for(int i=head[now];i;i=next[i])

			{

				if(d[to[i]]==-1&&val[i])

				{

					d[to[i]]=d[now]+1;

					q[r++]=to[i];

				}

			}

		}

		if(d[T]==-1)

		{

			return false;

		}

		else

		{

			return true;

		}

	}

	int dfs(int x,int maxflow)

	{

		if(x==T)

		{

			return maxflow;

		}

		int nowflow;

		int used=0;

		for(int i=head[x];i;i=next[i])

		{

			if(d[to[i]]==d[x]+1&&val[i])

			{

				nowflow=dfs(to[i],min(maxflow-used,val[i]));

				val[i]-=nowflow;

				val[i^1]+=nowflow;

				used+=nowflow;

				if(nowflow==maxflow)

				{

					return maxflow;

				}

			}

		}

		if(used==0)

		{

			d[x]=-1;

		}

		return used;

	}

	int dinic()

	{

		for(int i=2;i<=tot;i++)

		{

			val[i]=vir[i];

		}

		int res=0;

		while(bfs(S,T)==true)

		{

			res+=dfs(S,0x3f3f3f3f);

		}

		return res;

	}

	void find(int x)

	{

		col[x]=now;

		for(int i=head[x];i;i=next[i])

		{

			if(col[to[i]]!=now&&val[i])

			{

				find(to[i]);

			}

		}

	}

	void build(int l,int r)

	{

		if(l>=r)

		{

			return ;

		}

		S=id[l],T=id[l+1];

		int cut=dinic();

		now++;

		find(S);

		int L=l,R=r;

		for(int i=l;i<=r;i++)

		{

			if(col[id[i]]==now)

			{

				q[L++]=id[i];

			}

			else

			{

				q[R--]=id[i];

			}

		}

		for(int i=l;i<=r;i++)

		{

			id[i]=q[i];

		}

		add_edge(S,T,cut);

		add_edge(T,S,cut);

		build(l,L-1);

		build(R+1,r);

	}

};

void dfs(int x)

{

	for(int i=1;i<=10;i++)

	{

		f[x][i]=f[f[x][i-1]][i-1];

		g[x][i]=min(g[x][i-1],g[f[x][i-1]][i-1]);

	}

	for(int i=head[x];i;i=next[i])

	{

		if(to[i]!=f[x][0])

		{

			dep[to[i]]=dep[x]+1;

			f[to[i]][0]=x;

			g[to[i]][0]=val[i];

			dfs(to[i]);

		}

	}

}

int lca(int x,int y)

{

	int res=1<<30;

	if(dep[x]<dep[y])

	{

		swap(x,y);

	}

	int d=dep[x]-dep[y];

	for(int i=0;i<=10;i++)

	{

		if(d&(1<<i))

		{

			res=min(res,g[x][i]);

			x=f[x][i];

		}

	}

	if(x==y)

	{

		return res;

	}

	for(int i=10;i>=0;i--)

	{

		if(f[x][i]!=f[y][i])

		{

			res=min(res,g[x][i]);

			res=min(res,g[y][i]);

			x=f[x][i];

			y=f[y][i];

		}

	}

	res=min(min(g[x][0],g[y][0]),res);

	return res;

}

int main()

{

	scanf("%d%d",&n,&m);

	for(int i=1;i<=m;i++)

	{

		scanf("%d%d%d",&u,&v,&w);

		DINIC::add(u,v,w);

		DINIC::add(v,u,w);

	}

	for(int i=1;i<=n;i++)

	{

		id[i]=i;

	}

	DINIC::build(1,n);

	dfs(1);

	int ans=0;

	for(int i=1;i<=n;i++)

	{

		for(int j=i+1;j<=n;j++)

		{

			if(!mp[lca(i,j)])

			{

				mp[lca(i,j)]=1;

				ans++;

			}

		}

	}

	printf("%d",ans);

}