// 那就是希望。
// 即便需要取模，也是光明。

#include <algorithm>
#include <set>
#include <stdio.h>
#include <vector>
typedef long long llt;
typedef unsigned uint;typedef unsigned long long ullt;
typedef bool bol;typedef char chr;typedef void voi;
typedef double dbl;
template<typename T>bol _max(T&a,T b){return(a<b)?a=b,true:false;}
template<typename T>bol _min(T&a,T b){return(b<a)?a=b,true:false;}
template<typename T>T lowbit(T n){return n&-n;}
template<typename T>T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<typename T>T lcm(T a,T b){return(a!=0||b!=0)?a/gcd(a,b)*b:(T)0;}
template<typename T>T exgcd(T a,T b,T&x,T&y){if(b!=0){T ans=exgcd(b,a%b,y,x);y-=a/b*x;return ans;}else return y=0,x=1,a;}
template<typename T>T power(T base,T index,T mod)
{
    T ans=1%mod;
    while(index)
    {
        if(index&1)ans=ans*base%mod;
        base=base*base%mod,index>>=1;
    }
    return ans;
}
namespace ConstMod
{
template<const ullt p>
class mod_ullt
{
private:
    ullt v;
    inline ullt chg(ullt w){return(w<p)?w:w-p;}
    inline mod_ullt _chg(ullt w){mod_ullt ans;ans.v=(w<p)?w:w-p;return ans;}
public:
    mod_ullt():v(0){}
    mod_ullt(ullt v):v(v%p){}
    inline bol empty(){return!v;}
    inline ullt val(){return v;}
    inline ullt&operator()(){return v;}
    inline friend bol operator==(mod_ullt a,mod_ullt b){return a()==b();}
    inline friend bol operator!=(mod_ullt a,mod_ullt b){return a()!=b();}
    inline mod_ullt operator+(){return*this;}
    inline friend mod_ullt operator+(mod_ullt a,mod_ullt b){return a._chg(a()+b());}
    inline mod_ullt&operator+=(mod_ullt b){return*this=*this+b;}
    inline mod_ullt operator-(){return _chg(p-v);}
    inline friend mod_ullt operator-(mod_ullt a,mod_ullt b){return a+(-b);}
    inline mod_ullt&operator-=(mod_ullt b){return*this=*this-b;}
    inline friend mod_ullt operator*(mod_ullt a,mod_ullt b){return a()*b();}
    inline mod_ullt&operator*=(mod_ullt b){return*this=*this*b;}
    inline friend mod_ullt operator/(mod_ullt a,mod_ullt b){return a*b.inv();}
    inline mod_ullt&operator/=(mod_ullt b){return*this=*this/b;}
    friend mod_ullt operator^(mod_ullt a,ullt b)
    {
        mod_ullt v(1);
        while(b)
        {
            if(b&1)v*=a;
            a*=a,b>>=1;
        }
        return v;
    }
    inline mod_ullt&operator^=(ullt b){return*this=*this^b;}
    inline mod_ullt operator++(int){mod_ullt ans=*this;return v=chg(v+1),ans;}
    inline mod_ullt&operator++(){return v=chg(v+1),*this;}
    inline mod_ullt operator--(int){mod_ullt ans=*this;return v=chg(v+p-1),ans;}
    inline mod_ullt&operator--(){return v=chg(v+p-1),*this;}
    inline mod_ullt inv(){return(*this)^(p-2);}
    mod_ullt sqrt()
    {
        if(((*this)^((p-1)>>1))!=1)return 0;
        mod_ullt b(1);do b++;while((b^((p-1)>>1))==1);
        ullt t=p-1;uint s=0;while(!(t&1))s++,t>>=1;
        mod_ullt x=(*this)^((t+1)>>1),e=(*this)^t,w=inv();
        for(uint k=1;k<s;k++,e=w*x*x)if((e^(1llu<<(s-k-1)))!=1)x*=b^((1llu<<(k-1))*t);
        ullt ans=x();_min(ans,p-ans);return ans;
    }
    voi read()
    {
        v=0;chr c;do c=getchar();while(c>'9'||c<'0');
        do v=(c-'0'+v*10)%p,c=getchar();while(c>='0'&&c<='9');
    }
    voi print(chr endc='\0')
    {
        static chr C[20];uint tp=0;
        ullt w=v;do C[tp++]=w%10+'0',w/=10;while(w);
        while(tp--)putchar(C[tp]);
        if(endc)putchar(endc);
    }
    inline voi println(){print('\n');}
};
}
// Your shadow Gets in the way of my light
const ullt Mod=1e9+7;
typedef ConstMod::mod_ullt<Mod>modint;
typedef std::vector<modint>modvec;
std::vector<uint>Way[200005],Son[200005],Ps[200005];
std::vector<std::pair<uint,uint> >Es[200005];uint tp;
voi dfs(uint p,uint f)
{
    static uint Dep[200005],S[200005],Dfn[200005],F[200005],cnt;
    static std::vector<uint>B;std::vector<uint>A;
    if(!~f)for(auto&s:Dfn)s=-1;
    F[p]=f,Dep[p]=B.size(),B.push_back(p),Dfn[p]=cnt++;
    for(auto s:Way[p])if(s!=f)
    {
        if(~Dfn[s])
        {
            if(Dep[s]<Dep[p])S[B[Dep[s]+1]]--,S[p]++;
        }
        else A.push_back(s),dfs(s,p),S[p]+=S[s];
    }
    B.pop_back(),Son[p]=A;
    if(!~f)while(A.size())
    {
        B={A.back()},A.pop_back(),Ps[tp]={F[B[0]]};
        while(B.size())
        {
            Ps[tp].push_back(p=B.back()),B.pop_back();
            for(auto s:Son[p])(S[s]?B:A).push_back(s);
        }
        static bol Now[200005];
        for(auto s:Ps[tp])Now[s]=true;
        for(auto s:Ps[tp])for(auto ss:Way[s])if(s<ss&&Now[ss])Es[tp].push_back({s,ss});
        for(auto s:Ps[tp])Now[s]=false;
        tp++;
    }
}
uint D[200005];
int main()
{
#ifdef MYEE
    freopen("QAQ.in","r",stdin);
    freopen("QAQ.out","w",stdout);
#endif
    uint n,m;scanf("%u%u",&n,&m);
    while(m--){uint u,v;scanf("%u%u",&u,&v);Way[--u].push_back(--v),Way[v].push_back(u);}
    dfs(0,-1);
    modint ans(n);
    while(tp--)
    {
        for(auto p:Ps[tp])D[p]++;
        if(Ps[tp].size()==2)continue;
        ans*=2;
        static uint Xor[400005],Deg[200005],cnt;
        static std::vector<uint>Eid[200005],Q;
        std::set<std::pair<uint,uint> >M;
        for(auto p:Ps[tp])Eid[p].clear();
        cnt=0;
        for(auto e:Es[tp])
            M.insert(e),Eid[e.first].push_back(cnt),Eid[e.second].push_back(cnt),Xor[cnt++]=e.first^e.second;
        for(auto p:Ps[tp])if((Deg[p]=Eid[p].size())==2)Q.push_back(p);
        while(Q.size())
        {
            uint p=Q.back(),u=-1,v=-1;Q.pop_back();if(Deg[p]!=2)continue;
            Deg[p]=0;for(auto e:Eid[p])if(~Xor[e])(~u?v:u)=p^Xor[e],Xor[e]=-1u;
            if(u>v)std::swap(u,v);
            if(M.count({u,v}))
            {
                if(--Deg[u]==2)Q.push_back(u);
                if(--Deg[v]==2)Q.push_back(v);
            }
            else
                M.insert({u,v}),Eid[u].push_back(cnt),Eid[v].push_back(cnt),Xor[cnt++]=u^v;
        }
        for(auto p:Ps[tp])if(Deg[p]>1)return puts("0"),0;
    }
    for(uint i=0;i<n;i++)for(uint j=1;j<=D[i];j++)ans*=j;
    ans.println();
    return 0;
}

// 那就是希望。
// 即便需要取模，也是光明。