#include<iostream>

#include<cstdio>

#include<cmath>

#include<cstdlib>

#include<cstring>

#include<algorithm>

using namespace std;

#define ll long long

#define N 100050

#define P 998244353

char getc(){char c=getchar();while ((c<'A'||c>'Z')&&(c<'a'||c>'z')&&(c<''||c>'')) c=getchar();return c;}

int gcd(int n,int m){return m==?n:gcd(m,n%m);}

int read()

{

    int x=,f=;char c=getchar();

    while (c<''||c>'') {if (c=='-') f=-;c=getchar();}

    while (c>=''&&c<='') x=(x<<)+(x<<)+(c^),c=getchar();

    return x*f;

}

int n,m,p[N],f[N][],id[N][],dfn[N],size[N],fa[N][],deep[N],num[N][][],tmp[][],tot,cnt,t,u,ans=;

bool vis[N],flag[N];

struct data{int to,nxt;

}edge[N<<];

void addedge(int x,int y){t++;edge[t].to=y,edge[t].nxt=p[x],p[x]=t;}

int ksm(int a,int k)

{

    int s=;

    for (;k;k>>=,a=1ll*a*a%P) if (k&) s=1ll*s*a%P;

    return s;

}

int inv(int a){return ksm(a,P-);}

void dfs(int k)

{

    vis[k]=;f[k][]=f[k][]=;dfn[k]=++tot;size[k]=;

    for (int i=p[k];i;i=edge[i].nxt)

    if (edge[i].to!=fa[k][])

        if (vis[edge[i].to])

        {

            flag[k]=flag[edge[i].to]=;bool tag=;

            for (int j=;j<=cnt;j++) if (id[j][]==edge[i].to&&id[j][]==k) {tag=;break;}

            if (tag) cnt++,id[cnt][]=k,id[cnt][]=edge[i].to;

        }

        else

        {

            fa[edge[i].to][]=k;

            deep[edge[i].to]=deep[k]+;

            dfs(edge[i].to);

            f[k][]=1ll*f[k][]*(f[edge[i].to][]+f[edge[i].to][])%P,

            f[k][]=1ll*f[k][]*f[edge[i].to][]%P;

            size[k]+=size[edge[i].to];

        }

}

int lca(int x,int y)

{

    if (deep[x]<deep[y]) swap(x,y);

    for (int j=;~j;j--) if (deep[fa[x][j]]>=deep[y]) x=fa[x][j];

    if (x==y) return x;

    for (int j=;~j;j--) if (fa[x][j]!=fa[y][j]) x=fa[x][j],y=fa[y][j];

    return fa[x][];

}

namespace virtual_tree

{

    int m,p[N],t,g[N][],point[N],stk[N],top,cho[N];

    struct data{int to,nxt;}edge[N<<];

    void addedge(int x,int y){t++;flag[x]=flag[y]=;edge[t].to=y,edge[t].nxt=p[x],p[x]=t;}

    bool cmp(const int&a,const int&b){return dfn[a]<dfn[b];}

    void build()

    {

        for (int i=;i<=n;i++) if (flag[i]) point[++m]=i;

        sort(point+,point+m+,cmp);

        stk[top=]=;

        for (int i=(point[]==)+;i<=m;i++)

        {

            int x=lca(point[i],stk[top]);

            if (x==stk[top]) stk[++top]=point[i];

            else

            {

                while (top>&&deep[stk[top-]]>=deep[x])

                addedge(stk[top-],stk[top]),top--;

                if (stk[top]!=x) addedge(x,stk[top--]),stk[++top]=x;

                stk[++top]=point[i];

            }

        }

        while (top>) addedge(stk[top-],stk[top]),top--;

    }

    void copy(int k)

    {

        g[k][]=f[k][],g[k][]=f[k][];

        for (int i=p[k];i;i=edge[i].nxt)

        {

            copy(edge[i].to);

            g[k][]=1ll*g[k][]*inv((1ll*num[edge[i].to][][]*f[edge[i].to][]+1ll*num[edge[i].to][][]*f[edge[i].to][])%P)%P;

            g[k][]=1ll*g[k][]*inv((1ll*num[edge[i].to][][]*f[edge[i].to][]+1ll*num[edge[i].to][][]*f[edge[i].to][])%P)%P;

        }

    }

    void dp(int k)

    {

        if (cho[k]) g[k][]=;

        for (int i=p[k];i;i=edge[i].nxt)

        {

            dp(edge[i].to);

            g[k][]=1ll*g[k][]*((1ll*num[edge[i].to][][]*g[edge[i].to][]+1ll*num[edge[i].to][][]*g[edge[i].to][])%P)%P;

            g[k][]=1ll*g[k][]*((1ll*num[edge[i].to][][]*g[edge[i].to][]+1ll*num[edge[i].to][][]*g[edge[i].to][])%P)%P;

        }

    }

    int getans()

    {

        copy();

        dp();

        return (g[][]+g[][])%P;

    }

    void dfs(int k,int s)

    {

        if (k>cnt) {ans=((ans+s*getans())%P+P)%P;return;}

        cho[id[k][]]++,cho[id[k][]]++;dfs(k+,-s);

        cho[id[k][]]--,cho[id[k][]]--;dfs(k+,s);

    }

}

int main()

{

#ifndef ONLINE_JUDGE

    freopen("bzoj5287.in","r",stdin);

    freopen("bzoj5287.out","w",stdout);

    const char LL[]="%I64d\n";

#else

    const char LL[]="%lld\n";

#endif

    n=read(),m=read();

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

    {

        int x=read(),y=read();

        addedge(x,y),addedge(y,x);

    }

    fa[][]=;deep[]=;dfs();

    for (int j=;j<;j++)

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

        fa[i][j]=fa[fa[i][j-]][j-];

    virtual_tree::build();

    for (int i=;i<=n;i++) if (flag[i]) virtual_tree::point[++u]=i;

    for (int j=;j<=u;j++)

    {

        int i=virtual_tree::point[j];

        num[i][][]=num[i][][]=;

        if (i!=)

        {

            int x=fa[i][],y=i;

            do

            {

                tmp[][]=(num[i][][]+num[i][][])%P,tmp[][]=(num[i][][]+num[i][][])%P,

                tmp[][]=num[i][][],tmp[][]=num[i][][];

                num[i][][]=tmp[][],num[i][][]=tmp[][],num[i][][]=tmp[][],num[i][][]=tmp[][];

                if (!flag[x])

                for (int k=p[x];k;k=edge[k].nxt)

                if (edge[k].to!=y&&edge[k].to!=fa[x][])

                {

                    num[i][][]=1ll*num[i][][]*(f[edge[k].to][]+f[edge[k].to][])%P;

                    num[i][][]=1ll*num[i][][]*(f[edge[k].to][]+f[edge[k].to][])%P;

                    num[i][][]=1ll*num[i][][]*f[edge[k].to][]%P;

                    num[i][][]=1ll*num[i][][]*f[edge[k].to][]%P;

                }

                y=x,x=fa[x][];

            }while(!flag[y]);

        }

    }

    virtual_tree::dfs(,);

    cout<<ans;

    return ;

}