#include <iostream>
#include <vector>
#include <algorithm>
#include <set>
using namespace std;

long long n,m;
vector <vector <int> > G;
vector <pair<int,int> > M;

int dsu_parent[5000];
int dsu_rank[5000];
int size_of_component[5000];
int edges_of_component[5000];
set <int> all_components;
long long C[5001][5001];
long long answer_one=0,answer_two=0,answer_three=0,answer_four=0;
long long real_answer=0;
int MAXN=5000;

int dsu_make(int i){
    dsu_parent[i]=i;
    dsu_rank[i]=0;
}

void pascal_init(){
    for (int i = 0; i <= MAXN; i++) {
        C[i][0] = C[i][i] = 1;
        for (int k = 1; k < 10; k++)
            C[i][k] = C[i-1][k-1] + C[i-1][k];
    }
    real_answer=C[n][1]+C[n][2]+C[n][3]+C[n][4];
}

int dsu_find(int i){
    if (i==dsu_parent[i])
        return i;
    return dsu_parent[i]=dsu_find(dsu_parent[i]);
}

void dsu_unite(int a, int b){
    a=dsu_find(a);
    b=dsu_find(b);
    if (a!=b){
        if (dsu_rank[a]<dsu_rank[b])
            swap(a,b);
        dsu_parent[b]=a;
        size_of_component[a]+=size_of_component[b];
        edges_of_component[a]+=edges_of_component[b];
        all_components.erase(b);
        if (dsu_rank[a]==dsu_rank[b])
            dsu_rank[a]++;
    }
}

void iterat_for_three(int numb){
    int u=M[numb].first; int v=M[numb].second;
    long long k1=G[u].size();
    long long k2=G[v].size();
    sort (G[u].begin(),G[u].end());
    sort (G[v].begin(),G[v].end());
    vector <int> intersect_of_lists;
    vector<int>::iterator it=set_intersection(G[u].begin(),G[u].end(),G[v].begin(),G[v].end(),intersect_of_lists.begin());
    long long e=it-intersect_of_lists.begin();
    long long answer=(n-2)-k1-k2+e;
    answer_three+=answer;
}

void iterat_for_four(int numb){
    //cout<<"ENTER:"<<endl;
    int u=M[numb].first; int v=M[numb].second;
    int u_comp=dsu_find(u); int v_comp=dsu_find(v);
    long long k1=G[u].size();
    long long k2=G[v].size();
    long long answer=0;
    long long k=all_components.size();
    long long sums[5000];
    long long local_sizes[5000];
    for (int j=0;j<5000;j++)
        sums[j]=0,local_sizes[j]=0;
    int i=0;
    for (set<int>::iterator it=all_components.begin();it!=all_components.end();it++,i++){
        int cur_comp=*it;
        if (i) sums[i]+=sums[i-1];
        if (cur_comp!=u_comp && cur_comp!=v_comp){
            sums[i]+=size_of_component[cur_comp];
            local_sizes[i]=size_of_component[cur_comp];
            int socp=size_of_component[cur_comp];
            answer+=(socp*(socp-1))/2-edges_of_component[cur_comp];
        }
    }
    //cout<<"POINT1:"<<answer<<endl;
    for (int i=0;i<k;i++){
        long long chast_sum=sums[k-1];
        chast_sum-=sums[i];
        //cout<<local_sizes[i]<<" ";
        answer+=local_sizes[i]*chast_sum;
    }
    //cout<<"POINT2:"<<answer<<endl;
    if (u_comp!=v_comp){
        long long dob=0;
        long long socp=size_of_component[u_comp];
        dob+=(socp*(socp-1))/2-edges_of_component[u_comp];
        dob-=size_of_component[u_comp]-1-G[u].size();
        socp=size_of_component[v_comp];
        dob+=(socp*(socp-1))/2-edges_of_component[v_comp];
        dob-=size_of_component[v_comp]-1-G[v].size();
        answer+=dob;
        //cout<<"POINT2.5:"<<answer<<endl;
        answer+=(size_of_component[u_comp]-1-G[u].size())*(size_of_component[v_comp]-1-G[v].size());
        for (int i=0;i<k;i++){
            //cout<<"i:"<<i<<" "<<local_sizes[i]<<" "<<size_of_component[u_comp]<<endl;
            answer+=(size_of_component[u_comp]-1-G[u].size())*local_sizes[i];
        }
        //cout<<"POINT2.7:"<<answer<<endl;
        for (int i=0;i<k;i++){
            answer+=(size_of_component[v_comp]-1-G[v].size())*local_sizes[i];
        }
        //cout<<"POINT3:"<<answer<<endl;
    }
    else{
        long long dob=0;
        long long socp=size_of_component[u_comp];
        dob+=(socp*(socp-1))/2-edges_of_component[u_comp];
        dob-=size_of_component[u_comp]-1-G[u].size();
        dob-=size_of_component[v_comp]-1-G[v].size();
        answer+=dob;
        for (int i=0;i<k;i++){
            answer+=(size_of_component[u_comp]-2)*local_sizes[i];
        }
    }
    answer_four+=answer;
    G[u].push_back(u);
    G[v].push_back(v);
    dsu_unite(u,v);
    u_comp=dsu_find(u);
    edges_of_component[u_comp]++;
    //cout<<"EXIT"<<endl;
}

int main(){
    cin>>n>>m;
    G.resize(n);
    M.resize(m);
    answer_one=0; answer_two=m;
    for (int i=0;i<m;i++){
        int a,b; cin>>a>>b;
        a--; b--;
        if (a>b) swap(a,b);
        M[i]=(make_pair(a,b));
    }
    for (int i=0;i<n;i++){
        dsu_make(i);
        size_of_component[i]=1;
        all_components.insert(i);
    }
    for (int i=0;i<m;i++){
        iterat_for_three(i);
        iterat_for_four(i);
    }
    pascal_init();
    //cout<<answer_four<<endl;
    cout<<real_answer-answer_one-answer_two-answer_three-answer_four<<endl;
    return 0;
}