Description
从前有一名毒瘤。

毒瘤最近发现了量产毒瘤题的奥秘。考虑如下类型的数据结构题：给出一个数组，要求支持若干种奇奇怪怪的修改操作（比如区间加一个数，或者区间开平方），并支持询问区间和。毒瘤考虑了\(n\)个这样的修改操作，并编号为\(1\sim n\)。当毒瘤要出数据结构题的时候，他就将这些修改操作中选若干个出来，然后出成一道题。

当然了，这样出的题有可能不可做。通过精妙的数学推理，毒瘤揭露了这些修改操作的关系：有\(m\)对“互相排斥”的修改操作，第\(i\)对是第\(u_i\)个操作和第\(v_i\)个操作。当一道题同时含有\(u_i\)和\(v_i\)这两个操作时，这道题就会变得不可做。另一方面，一道题中不包含任何“互相排斥”的修改操作时，这个题就是可做的。此外，毒瘤还发现了一个规律：\(m-n\)是一个很小的数字，且任意两个修改操作都是连通的。两个修改操作\(a,b\)是连通的，当且仅当存在若干操作\(t_0,t_1,...,t_l\)，使得\(t_0=a,t_l=b\)，且对\(1\leqslant i\leqslant l\)，\(t_{i-1}\)和\(t_i\)都是“互相排斥”的修改操作。

一堆“互相排斥”的修改操作称为互斥对。现在毒瘤想知道，给定值\(n\)和\(m\)个互斥对，他共能出出多少道可做的不同的数据结构题。两道数据结构题是不同的，当且仅当有一个修改操作在其中一道题中存在，而在另一道题中不存在。

Input
第一行为正整数\(n,m\)。
接下来\(m\)行，每行两个正整数\(u,v\)，代表一对“互相排斥”的修改操作。

Output
输出一行一个整数，代表毒瘤可以出的可做的不同的“互相排斥”的修改操作的个数。这个数可能很大，所以只输出模998244353后的值。

Sample Input 1
3 2
1 2
2 3

Sample Output 1
5

Sample Input 2
6 8
1 2
1 3
1 4
2 4
3 5
4 5
4 6
1 6

Sample Output 2
16

Sample Input 3
12 18
12 6
3 11
8 6
2 9
10 4
1 8
6 2
11 5
10 6
12 2
9 3
7 6
2 7
3 2
7 3
5 6
2 11
12 1

Sample Output 3
248

HINT

首先考虑\(m=n-1\)的情况，我们直接做一遍tree dp，设\(f[u][0/1]\)表示点\(u\)选或不选的方案数，转移即为\[\begin{cases}f[u][0]=\prod\limits_{u\rightarrow v}(f[v][0]+f[v][1])\\f[u][1]=\prod\limits_{u\rightarrow v}f[v][0]\end{cases}\]

这样我们可以得到10pts的好成绩，那么多出来的非树边如何处理？因为最多只有11条非树边，暴力枚举端点状态，只有\((1,0),(0,0),(0,1)\)三种，但其实只要枚举一个点选或不选，\((0,0)\)和\((0,1)\)可以合并起来，复杂度\(O(2^{m-n+1}n)\)，可以得到75pts的好成绩

如何拿满分？我们发现上面的算法重复计算了很多状态，我们把非树边影响的点取出来，记为关键点，影响dp值的只有这些点，我们把这些关键点（至多22个）建立一棵虚树，dp方程可以转化为\[\begin{cases}f[u][0]=\prod\limits_{u\rightarrow v}k_{u\rightarrow v,0,0}\times f[v][0]+k_{u\rightarrow v,0,1}\times f[v][1]\\f[u][1]=\prod\limits_{u\rightarrow v}k_{u\rightarrow v,1,0}\times f[v][0]+k_{u\rightarrow v,1,1}\times f[v][1]\end{cases}\]

其实可以发现，\(k_{u\rightarrow v,0/1,0/1}\)是不会变化的，那么我们就先预处理出系数，如何求？\(v\)在原树上暴力向上跳，累计统计系数即可，记得统计的时候不能重复统计

这样转移的复杂度是\(O(n)\)的，对于虚树上的边我们暴力枚举状态，然后转移，记\(s\)为关键点数，则复杂度为\(O(n+s2^s)\)

/*program from Wolfycz*/
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#define Fi first
#define Se second
#define MK make_pair
#define inf 0x7f7f7f7f
using namespace std;
typedef long long ll;
typedef unsigned int ui;
typedef pair<int,int> pii;
typedef unsigned long long ull;
inline char gc(){static char buf[1000000],*p1=buf,*p2=buf;return p1==p2&&(p2=(p1=buf)+fread(buf,1,1000000,stdin),p1==p2)?EOF:*p1++;
}
inline int frd(){int x=0,f=1; char ch=gc();for (;ch<'0'||ch>'9';ch=gc())   if (ch=='-')    f=-1;for (;ch>='0'&&ch<='9';ch=gc()) x=(x<<3)+(x<<1)+ch-'0';return x*f;
}
inline int read(){int x=0,f=1; char ch=getchar();for (;ch<'0'||ch>'9';ch=getchar())  if (ch=='-')    f=-1;for (;ch>='0'&&ch<='9';ch=getchar())    x=(x<<3)+(x<<1)+ch-'0';return x*f;
}
inline void print(int x){if (x<0)    putchar('-'),x=-x;if (x>9)    print(x/10);putchar(x%10+'0');
}
const int N=1e5,Mod=998244353;
struct S1{int x,y;S1(){x=y=0;}void insert(int _x,int _y){x=_x,y=_y;}
}NT[15];//Not in Tree
int NT_cnt,dfn[N+10];
bool cmp(int x,int y){return dfn[x]<dfn[y];}
struct S2{int pre[(N<<1)+10],now[N+10],child[(N<<1)+10],tot,Time;int fa[N+10],size[N+10],deep[N+10],Rem[N+10],top[N+10],f[N+10][2];bool vis[N+10];void join(int x,int y){pre[++tot]=now[x],now[x]=tot,child[tot]=y;}void insert(int x,int y){join(x,y),join(y,x);}void dfs(int x){deep[x]=deep[fa[x]]+1,size[x]=1;for (int p=now[x],son=child[p];p;p=pre[p],son=child[p]){if (son==fa[x]) continue;fa[son]=x,dfs(son);size[x]+=size[son];if (size[Rem[x]]<size[son]) Rem[x]=son;}}void build(int x){if (!x) return;dfn[x]=++Time;top[x]=Rem[fa[x]]==x?top[fa[x]]:x;build(Rem[x]);for (int p=now[x],son=child[p];p;p=pre[p],son=child[p]){if (son==fa[x]||son==Rem[x])    continue;build(son);}}int LCA(int x,int y){while (top[x]!=top[y]){if (deep[top[x]]<deep[top[y]])  swap(x,y);x=fa[top[x]];}return deep[x]<deep[y]?x:y;}void dp(int x){//在原树上dp一次，处理出原本的dp系数ff[x][0]=f[x][1]=1;for (int p=now[x],son=child[p];p;p=pre[p],son=child[p]){if (son==fa[x]) continue;dp(son);f[x][1]=1ll*f[x][1]*f[son][0]%Mod;f[x][0]=1ll*f[x][0]*(f[son][0]+f[son][1])%Mod;}}int work(int x,int y,int xv,int yv){//deep[x]<deep[y]//暴力上跳，求出边的系数static int tmp[2];tmp[yv]=1,tmp[yv^1]=0;while (x!=y){vis[y]=1;for (int p=now[y],son=child[p];p;p=pre[p],son=child[p]){if (son==fa[y]||vis[son])   continue;tmp[1]=1ll*tmp[1]*f[son][0]%Mod;tmp[0]=1ll*tmp[0]*(f[son][0]+f[son][1])%Mod;}swap(tmp[0],tmp[1]);tmp[0]=(tmp[0]+tmp[1])%Mod;//f[x][1]=f[son][0];//f[x][0]=f[son][0]+f[son][1];//向上跳一次要按如上方法转移，所以tmp数组需要按如上方法处理y=fa[y];}return tmp[xv];}pii work(int x){//处理关键点在虚树上应有的值static int tmp[2];tmp[0]=tmp[1]=1;for (int p=now[x],son=child[p];p;p=pre[p],son=child[p]){if (son==fa[x]||vis[son])   continue;vis[son]=1;tmp[1]=1ll*tmp[1]*f[son][0]%Mod;tmp[0]=1ll*tmp[0]*(f[son][0]+f[son][1])%Mod;}return MK(tmp[0],tmp[1]);}
}HLD;//Heavy Light Decomposition
const int M=22;
struct S3{int pre[(M<<2)+10],now[N+10],child[(M<<2)+10],tot,m;int V[(M<<2)+10][2][2];//V[p][i][j]: p:u->v i:u(0/1) j:v(0/1)int vis[N+10];//special point(0/1); normal point(-1)int f[N+10][2],g[N+10][2],A[M+10];void join(int x,int y){pre[++tot]=now[x],now[x]=tot,child[tot]=y;}void insert(int x,int y){join(x,y),join(y,x);}void rebuild(){static int stack[(M<<1)+10],top=0;for (int i=1;i<=NT_cnt;i++) A[++m]=NT[i].x,A[++m]=NT[i].y;sort(A+1,A+1+m);m=unique(A+1,A+1+m)-A-1;stack[++top]=1;sort(A+1,A+1+m,cmp);for (int i=1;i<=m;i++){int x=A[i],lca=HLD.LCA(x,stack[top]);if (x==1)   continue;if (lca==stack[top]){stack[++top]=x;continue;}while (true){int y=stack[top-1];if (dfn[y]>=dfn[lca])   insert(stack[top--],y);else{if (lca==stack[top])    break;insert(stack[top],lca);stack[top]=lca; break;}}stack[++top]=x;}while (top>1){insert(stack[top-1],stack[top]);top--;}}void prepare(int x,int fa){for (int p=now[x],son=child[p];p;p=pre[p],son=child[p]){if (son==fa)    continue;prepare(son,x);for (int i=0;i<2;i++)for (int j=0;j<2;j++)V[p][i][j]=HLD.work(x,son,i,j);}//求出每个点本身应有的dp值，边的系数只考虑边，不考虑端点pii tmp=HLD.work(x);g[x][0]=tmp.Fi,g[x][1]=tmp.Se;}void dp(int x,int fa){if (vis[x]==-1) f[x][0]=g[x][0],f[x][1]=g[x][1];else    f[x][vis[x]]=g[x][vis[x]],f[x][vis[x]^1]=0;for (int p=now[x],son=child[p];p;p=pre[p],son=child[p]){if (son==fa)    continue;dp(son,x);f[x][1]=1ll*f[x][1]*(1ll*f[son][0]*V[p][1][0]%Mod+1ll*f[son][1]*V[p][1][1]%Mod)%Mod;f[x][0]=1ll*f[x][0]*(1ll*f[son][0]*V[p][0][0]%Mod+1ll*f[son][1]*V[p][0][1]%Mod)%Mod;}}void work(){rebuild();prepare(1,0);memset(vis,255,sizeof(vis));int Ans=0;for (int sta=0;sta<1<<m;sta++){for (int i=1;i<=m;i++)  vis[A[i]]=(sta>>(i-1))&1;bool flag=1;for (int i=1;i<=NT_cnt;i++){if (vis[NT[i].x]&&vis[NT[i].y]){flag=0;break;}}if (!flag)  continue;dp(1,0);Ans=(Ans+(f[1][0]+f[1][1])%Mod)%Mod;}printf("%d\n",Ans);}
}VT;//Virtual Tree
struct S4{int fa[N+10];S4(){for (int i=1;i<=N;i++) fa[i]=i;}int find(int x){return x==fa[x]?x:fa[x]=find(fa[x]);}
}DSU;//Disjoint Set Union
int main(){int n=read(),m=read();for (int i=1;i<=m;i++){int x=read(),y=read(),fx,fy;if ((fx=DSU.find(x))!=(fy=DSU.find(y))){DSU.fa[fx]=fy;HLD.insert(x,y);}else   NT[++NT_cnt].insert(x,y);}HLD.dfs(1),HLD.build(1),HLD.dp(1);VT.work();return 0;
}