We have a grid with N rows and N columns. The cell at the i-th row and j-th column is denoted (i, j).

Initially, M of the cells are painted black, and all other cells are white. Specifically, the cells (a_1, b_1), (a_2, b_2), ..., (a_M, b_M) are painted black.

Snuke will try to paint as many white cells black as possible, according to the following rule:

* If two cells (x, y) and (y, z) are both black and a cell (z, x) is white for integers 1≤x,y,z≤N, paint the cell (z, x) black.



Find the number of black cells when no more white cells can be painted black.

Constraints

* 1≤N≤10^5
* 1≤M≤10^5
* 1≤a_i,b_i≤N
* All pairs (a_i, b_i) are distinct.

Input

The input is given from Standard Input in the following format:


N M
a_1 b_1
a_2 b_2
:
a_M b_M


Output

Print the number of black cells when no more white cells can be painted black.

Examples

Input

3 2
1 2
2 3


Output

3


Input

2 2
1 1
1 2


Output

4


Input

4 3
1 2
1 3
4 4


Output

3
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<math.h> 
using namespace std;
struct edge{
    long long v,ty,next;
    edge(long long v=0,long long ty=0,long long next=0):v(v),ty(ty),next(next){}
}e[1000003<<1];
long long n,m,col[1000003],cnt[3],siz;
long long tot=0,head[1000003];
bool flag;
inline void add(long long u,long long v,long long ty){
	e[++tot]=edge(v,ty,head[u]),head[u]=tot;
}
void dfs(long long u){
    cnt[col[u]]++;
    for(long long i=head[u];i;i=e[i].next){
		long long v=e[i].v,ty=e[i].ty;
		siz+=(ty==1);
		if(col[v]>=0){
			flag|=(col[v]!=(col[u]+ty)%3);
		}else{
			col[v]=(col[u]+ty)%3,dfs(v);
		}
	}
}
int main(){
	cin>>n>>m;
	for(int i=1;i<=m;i++){
		long long x,y;
		cin>>x>>y;
		add(x,y,1),add(y,x,2);
	}
    memset(col,-1,sizeof(col));
    long long ans=0;
    for(int i=1;i<=n;i++){
    	if(col[i]>=0){
    		continue;
		}
        cnt[col[i]=0]=cnt[1]=cnt[2]=siz=flag=0;
        dfs(i);
        if(flag){
        	ans+=(cnt[0]+cnt[1]+cnt[2])*(cnt[0]+cnt[1]+cnt[2]);
		}else if(cnt[0]&&cnt[1]&&cnt[2]){
        	ans+=cnt[0]*cnt[1]+cnt[1]*cnt[2]+cnt[2]*cnt[0];
		}else{
        	ans+=siz;
		}
	}
	cout<<ans<<endl;
    return 0;
}