#include <bits/stdc++.h>
#define int long long
using namespace std;

string to_string(string s) { return s; }
template <typename T> string to_string(T v) {
  bool first = true;
  string res = "[";
  for (const auto &x : v) {
    if (!first)
      res += ", ";
    first = false;
    res += to_string(x);
  }
  res += "]";
  return res;
}

void dbg_out() { cout << endl; }
template <typename Head, typename... Tail> void dbg_out(Head H, Tail... T) {
  cout << ' ' << to_string(H);
  dbg_out(T...);
}

#ifdef DEBUG
#define dbg(...) cout << "(" << #__VA_ARGS__ << "):", dbg_out(__VA_ARGS__)
#else
#define dbg(...)
#endif

const int MOD = 998244353;

int add(int a, int b) {
  a += b;
  if (a >= MOD)
    a -= MOD;
  return a;
}

int sub(int a, int b) {
  a -= b;
  if (a < 0)
    a += MOD;
  return a;
}

int mult(int a, int b) { return a * b % MOD; }

const int MAX = 5000 * 5000 + 1;
int pow2[MAX];

vector<int> bridge;
vector<vector<pair<int, int>>> ed;

vector<int> num, st;
int Time;

int dfs(int at, int par) {
  int me = num[at] = ++Time, e, y, top = me;
  for (auto pa : ed[at])
    if (pa.second != par) {
      tie(y, e) = pa;
      if (num[y]) {
        top = min(top, num[y]);
        if (num[y] < me)
          st.push_back(e);
      } else {
        int si = st.size();
        int up = dfs(y, e);
        top = min(top, up);
        if (up == me) {
          st.push_back(e);
          st.resize(si);
        } else if (up < me)
          st.push_back(e);
        else
          bridge[e] = true;
      }
    }
  return top;
}

void bicomps() {
  num.assign(ed.size(), 0);
  for (int i = 0; i < (int)ed.size(); ++i)
    if (!num[i])
      dfs(i, -1);
}

struct UnionFind {
  vector<int> id;

  UnionFind(int N) : id(N, -1) {}

  int find(int u) {
    if (id[u] < 0)
      return u;
    return id[u] = find(id[u]);
  }

  bool merge(int u, int v) {
    u = find(u), v = find(v);
    if (u == v)
      return false;
    if (id[u] > id[v])
      swap(u, v);
    id[u] += id[v];
    id[v] = u;
    return true;
  }
};

signed main(void) {
  ios_base::sync_with_stdio(false);
  cin.tie(0);

  pow2[0] = 1;
  for (int i = 1; i < MAX; ++i)
    pow2[i] = add(pow2[i - 1], pow2[i - 1]);

  int nbSommets, nbAretes;
  cin >> nbSommets >> nbAretes;
  bridge.assign(nbAretes, false);

  ed.resize(nbSommets);
  vector<pair<int, int>> aretes(nbAretes);
  for (int i = 0; i < nbAretes; ++i) {
    auto &[u, v] = aretes[i];
    cin >> u >> v;
    --u, --v;
    ed[u].emplace_back(v, i);
    ed[v].emplace_back(u, i);
  }

  bicomps();

  UnionFind dsu(nbSommets);

  for (int i = 0; i < nbAretes; ++i)
    if (!bridge[i])
      dsu.merge(aretes[i].first, aretes[i].second);
  dbg(dsu.id);

  vector<int> roots;
  for (int u = 0; u < nbSommets; ++u)
    if (dsu.id[u] < 0)
      roots.push_back(u);

  auto getId = [&](int u) {
    return lower_bound(roots.begin(), roots.end(), u) - roots.begin();
  };

  int nbCC = roots.size();
  vector<int> szCC(nbCC);
  for (int u = 0; u < nbSommets; ++u)
    szCC[getId(dsu.find(u))]++;

  vector<vector<int>> adj(nbCC);
  for (int i = 0; i < nbAretes; ++i)
    if (bridge[i]) {
      auto [u, v] = aretes[i];
      u = getId(u), v = getId(v);
      adj[u].push_back(v);
      adj[v].push_back(u);
    }

  auto merge = [&](vector<int> &dpRoot, vector<int> &dpSon) {
    vector<int> ret(dpRoot.size() + dpSon.size() - 1);
    for (int szRoot = 1; szRoot < (int)dpRoot.size(); ++szRoot)
      for (int szSon = 1; szSon < (int)dpSon.size(); ++szSon) {
        // not bad
        ret[szRoot + szSon] = add(
            ret[szRoot + szSon],
            mult(dpRoot[szRoot], mult(dpSon[szSon], pow2[szSon * szRoot - 1])));
        // bad
        ret[szRoot] = sub(ret[szRoot], mult(dpRoot[szRoot], dpSon[szSon]));
      }
    return ret;
  };

  auto Solve = [&](auto solve, int u, int p) -> vector<int> {
    vector<int> dp(szCC[u] + 1);
    dp[szCC[u]] = 1;
    for (int v : adj[u])
      if (v != p) {
        vector<int> dpSon = solve(solve, v, u);
        dp = merge(dp, dpSon);
      }
    dbg(u + 1, dp);
    return dp;
  };

  vector<int> ret = Solve(Solve, 0, 0);

  int sol = 0;
  for (int x : ret)
    sol = add(sol, x);
  dbg(sol);
  for (int u = 0; u < nbCC; ++u)
    sol = mult(sol, pow2[szCC[u] * (szCC[u] - 1) / 2]);
  for (int i = 0; i < nbAretes; ++i)
    if (!bridge[i])
      sol = mult(sol, (MOD + 1) / 2);
  cout << sol << endl;
}