#include <bits/stdc++.h>
#define rep(i,j,k) for(int i=(j);i<=(k);i++)
#define per(i,j,k) for(int i=(j);i>=(k);i--)
#define uint unsigned int
#define ll long long
#define ull unsigned long long
#define db double
#define ldb long double
#define pii pair<int,int>
#define pll pair<ll,ll>
#define mkp make_pair
#define eb emplace_back
#define SZ(S) (int)S.size()
//#define mod 998244353
#define mod 1000000007
#define inf 0x3f3f3f3f
#define linf 0x3f3f3f3f3f3f3f3f
using namespace std;

template <class T>
void chkmax(T &x,T y){
    if(x < y) x = y;
}

template <class T>
void chkmin(T &x,T y){
    if(x > y) x = y;
}

inline int popcnt(int x){
    return __builtin_popcount(x);
}

inline int ctz(int x){
    return __builtin_ctz(x);
}

template <int P>
class mod_int
{
    using Z = mod_int;

private:
    static int mo(int x) { return x < 0 ? x + P : x; }

public:
    int x;
    int val() const { return x; }
    mod_int() : x(0) {}
    template <class T>
    mod_int(const T &x_) : x(x_ >= 0 && x_ < P ? static_cast<int>(x_) : mo(static_cast<int>(x_ % P))) {}
    bool operator==(const Z &rhs) const { return x == rhs.x; }
    bool operator!=(const Z &rhs) const { return x != rhs.x; }
    Z operator-() const { return Z(x ? P - x : 0); }
    Z pow(long long k) const
    {
        Z res = 1, t = *this;
        while (k)
        {
            if (k & 1)
                res *= t;
            if (k >>= 1)
                t *= t;
        }
        return res;
    }
    Z &operator++()
    {
        x < P - 1 ? ++x : x = 0;
        return *this;
    }
    Z &operator--()
    {
        x ? --x : x = P - 1;
        return *this;
    }
    Z operator++(int)
    {
        Z ret = x;
        x < P - 1 ? ++x : x = 0;
        return ret;
    }
    Z operator--(int)
    {
        Z ret = x;
        x ? --x : x = P - 1;
        return ret;
    }
    Z inv() const { return pow(P - 2); }
    Z &operator+=(const Z &rhs)
    {
        (x += rhs.x) >= P && (x -= P);
        return *this;
    }
    Z &operator-=(const Z &rhs)
    {
        (x -= rhs.x) < 0 && (x += P);
        return *this;
    }
    Z operator-()
    {
        return -x;
    }
    Z &operator*=(const Z &rhs)
    {
        x = 1ULL * x * rhs.x % P;
        return *this;
    }
    Z &operator/=(const Z &rhs) { return *this *= rhs.inv(); }
#define setO(T, o)                                  \
    friend T operator o(const Z &lhs, const Z &rhs) \
    {                                               \
        Z res = lhs;                                \
        return res o## = rhs;                       \
    }
    setO(Z, +) setO(Z, -) setO(Z, *) setO(Z, /)
#undef setO
    
    friend istream& operator>>(istream& is, mod_int& x)
    {
        long long tmp;
        is >> tmp;
        x = tmp;
        return is;
    }
    friend ostream& operator<<(ostream& os, const mod_int& x)
    {
        os << x.val();
        return os;
    }
};

using Z = mod_int<mod>;
Z power(Z p,ll k){
    Z ans = 1;
    while(k){
        if(k % 2 == 1) ans *= p;
        p *= p;
        k /= 2;
    }
    return ans;
}
int n,m;
int _u[200005],_v[200005];
Z fact[200005];

int cnt;
int head[200005];
struct eg{
    int to,nxt;
}edge[800005];

void make(int u,int v){
    edge[++cnt].to = v;
    edge[cnt].nxt = head[u];
    head[u] = cnt;
}

int dfn[200005],low[200005],N;
vector <int> sta,scc[200005],idx[400005];
void tarjan(int u){
    dfn[u] = low[u] = ++cnt;
    sta.eb(u);
    for(int i = head[u];i;i = edge[i].nxt){
        int v = edge[i].to;
        if(!dfn[v]){
            tarjan(v);
            chkmin(low[u],low[v]);
            if(low[v] == dfn[u]){
                ++N;
                scc[N].eb(u);
                while(1){
                    int p = sta.back();
                    sta.pop_back();
                    scc[N].eb(p);
                    if(p == v) break;
                }
            }
        }else{
            chkmin(low[u],dfn[v]);
        }
    }
}
vector <int> son[400005];
int anc[400005];
void dfs(int u,int f){
    anc[u] = f;
    for(int v:son[u]) if(v != f) dfs(v,u);
}

queue <int> Q;
int deg[200005],qwq[200005];

map <int,int> G[200005];
void add(int u,int v){
//    printf("add %d %d\n",u,v);
    qwq[u]++;qwq[v]++;
    make(u,v);
    make(v,u);
}

void test(int u){
    deg[u]--;
    if(deg[u] == 2) Q.push(u);
}

int vis[200005];
void dfs2(int u){
    vis[u] = 1;
    for(int i = head[u];i;i = edge[i].nxt){
        int v = edge[i].to;
        if(!vis[v]) dfs2(v);
    }
}
int rk[200005];

int main(){
//    freopen("graph13.in","r",stdin);
    scanf("%d%d",&n,&m);
    fact[0] = 1;
    rep(i,1,n) fact[i] = fact[i - 1] * i;
    rep(i,1,m){
        scanf("%d%d",&_u[i],&_v[i]);
        make(_u[i],_v[i]);make(_v[i],_u[i]);
    }
    cnt = 0;
    tarjan(1);
    rep(c,1,N){
        for(int u:scc[c]){
            son[n + c].eb(u);
            son[u].eb(n + c);
        }
    }
    dfs(1,0);

    rep(i,1,m){
        if(anc[_u[i]] == anc[_v[i]]){
            idx[anc[_u[i]]].eb(i);
            continue;
        }
        if(anc[anc[_u[i]]] == _v[i]) idx[anc[_u[i]]].eb(i);
        else if(anc[anc[_v[i]]] == _u[i]) idx[anc[_v[i]]].eb(i);
        else assert(0);
    }

//    printf("qwq\n");
    Z ans = n;
    cnt = 0;
    memset(head,0,sizeof(head));
    rep(c,1,N){
/*        printf("vcc %d\n",c); 
        for(int id:idx[n + c]) printf("%d %d\n",_u[id],_v[id]);
        printf("\n");
        for(int u:scc[c]) printf("%d ",u);
        printf("\n");*/

        if(SZ(scc[c]) == 2){
            add(_u[idx[n + c].back()],_v[idx[n + c].back()]);
            qwq[_u[idx[n + c].back()]] = qwq[_v[idx[n + c].back()]] = 0;
            continue;
        }
        ans *= 2;
        
        for(int id:idx[n + c]){
            G[_u[id]][_v[id]] = 1;
            G[_v[id]][_u[id]] = 1;
            deg[_u[id]]++;deg[_v[id]]++;
        }
        for(int u:scc[c]) if(deg[u] == 2) Q.push(u);

        rep(k,1,SZ(scc[c]) - 2){
            if(Q.empty()){
                printf("0\n");
                return 0;
            }
            int u = Q.front();
            Q.pop();
            int p = -1,q = -1;
            for(pii I:G[u]){
                if(!I.second) continue;
                if(p == -1) p = I.first;
                else if(q == -1) q = I.first;
                else assert(0);
                if(I.second == 1) add(u,I.first);
            }
//          printf("erase %d p=%d q=%d\n",u,p,q);
            if(q == -1){
                printf("0\n");
                return 0;
            }
            G[p][u] = G[q][u] = 0;
            G[u].clear();
            if(G[p].find(q) != G[p].end() && G[p][q]){
                test(p);
                test(q);
            }
            if(k + 2 < SZ(scc[c])){
                G[p][q] = G[q][p] = 2;
            }else{
                chkmax(G[p][q],1);
                chkmax(G[q][p],1);
            }
        }
        if(SZ(Q) < 2){
            printf("0\n");
            return 0;
        }
        assert(SZ(Q) == 2);
        int p = Q.front();Q.pop();
        int q = Q.front();Q.pop();
        if(G[p][q] == 1) add(p,q);
        G[p].clear();G[q].clear();

        for(int u:scc[c]){
            if(qwq[u] != 2){
                printf("0\n");
                return 0;
            }
            qwq[u] = deg[u] = 0;
        }
    }
    dfs2(1);
    rep(u,1,n){
        if(!vis[u]){
            printf("0\n");
            return 0;
        }
    }
    rep(c,1,N){
        for(int u:scc[c]) rk[u]++;
    }
    rep(u,1,n) ans *= fact[rk[u]];
    printf("%d\n",ans.val());
    return 0;
}