#include<iostream>
#include<cstring>
#include<vector>
#include<set>
#include<map>
#include<bitset>
#include<algorithm>
using namespace std;
using LL = long long;
const int mod = 998244353;

void add(int &a, int b){
    a += b;
    if (a >= mod) a -= mod;
}

int pls(int a, int b){
    a += b;
    if (a >= mod) a -= mod;
    return a;
}

int mul(int a, int b){
    return 1LL * a * b % mod;
}

int qpow(int a, int b){
    int ans = 1;
    while(b){
        if (b & 1) ans = mul(ans, a);
        b >>= 1;
        a = mul(a, a);
    }
    return ans;
}

const int maxn = 1e5 + 5;
int p[maxn];

int find(int x){
    return p[x] == x ? x : p[x] = find(p[x]);
}

bool merge(int x, int y){
    x = find(x), y = find(y);
    if (x != y){
        p[x] = y;
        return true;
    }
    return false;
}

int dep[maxn], sz[maxn], in[maxn], out[maxn], top[maxn], fa[maxn], seq[maxn], ts;

vector<int> g[maxn];

void dfs_sz(int u){
    if (fa[u]){
        g[u].erase(find(g[u].begin(), g[u].end(), fa[u]));
    }
    sz[u] = 1;
    for(auto &j : g[u]){
        fa[j] = u;
        dep[j] = dep[u] + 1;
        dfs_sz(j);
        sz[u] += sz[j];
        if (sz[j] > sz[g[u][0]]) swap(j, g[u][0]);
    }
}

void dfs_hld(int u){
    in[u] = ++ts;
    out[top[u]] = ts;
    seq[ts] = u;
    for(auto j : g[u]){
        top[j] = (j == g[u][0] ? top[u] : j);
        dfs_hld(j);
    }
}

const int N = 2;
struct Matrix{
    int a[2][2];

    Matrix(){
        a[0][0] = a[1][1] = 1;
        a[0][1] = a[1][0] = 0;
    }

    Matrix operator*(const Matrix &t) const {
        Matrix ans;
        memset(ans.a, 0, sizeof ans.a);
        for(int i = 0; i < N; i++){
            for(int j = 0; j < N; j++){
                LL sum = 0;
                for(int k = 0; k < N; k++){
                    sum += 1LL * a[i][k] * t.a[k][j];
                }
                ans.a[i][j] = sum % mod;
            }
        }
        return ans;
    }
};

struct Vector{
    int a[2];

    Vector(){
        a[0] = a[1] = 0;
    }

    Vector operator*(const Matrix &t) const {
        Vector ret = Vector();
        for(int i = 0; i < 2; i++){
            LL ans = 0;
            for(int j = 0; j < 2; j++){
                ans += 1LL * a[j] * t.a[j][i];
            }
            ret.a[i] = ans % mod;
        }
        return ret;
    }

};

Matrix tr[maxn * 4], val[maxn];

void modify(int u, int l, int r, int x, const Matrix &v){
    if (l == r){
        tr[u] = v;
        return;
    }
    int mid = (l + r) / 2;
    if (x <= mid) modify(2 * u, l, mid, x, v);
    else modify(2 * u + 1, mid + 1, r, x, v);
    tr[u] = tr[2 * u + 1] * tr[2 * u];
}

Vector ret;

void query(int u, int l, int r, int L, int R){
    if (l > R or r < L) return;
    if (l >= L and r <= R){
        ret = ret * tr[u];
        return;
    }
    int mid = (l + r) / 2;
    query(2 * u + 1, mid + 1, r, L, R);
    query(2 * u, l, mid, L, R);
}

// f 0/1 : 不取/取
int f[maxn][2], h[maxn][2], c[maxn][2];

void dfs(int u){
    h[u][0] = h[u][1] = 1;
    for(auto j : g[u]){
        dfs(j);
        if (j == g[u][0]) continue;
        if (f[j][0] == 0){
            c[u][1] += 1;
        }
        else{
            h[u][1] = mul(h[u][1], f[j][0]);
        }
        int t = pls(f[j][0], f[j][1]);
        if (t == 0){
            c[u][0] += 1;
        }
        else{
            h[u][0] = mul(h[u][0], t);
        }
    }
    f[u][0] = (c[u][0] > 0 ? 0 : h[u][0]);
    f[u][1] = (c[u][1] > 0 ? 0 : h[u][1]);
    if (!g[u].empty()){
        f[u][1] = mul(f[u][1], f[g[u][0]][0]);
        f[u][0] = mul(f[u][0], f[g[u][0]][0] + f[g[u][0]][1]);
    }
    val[u].a[0][0] = (c[u][0] > 0 ? 0 : h[u][0]);
    val[u].a[0][1] = (c[u][1] > 0 ? 0 : h[u][1]);
    val[u].a[1][0] = (c[u][0] > 0 ? 0 : h[u][0]);
    val[u].a[1][1] = 0;
}

void build(int u, int l, int r){
    if (l == r){
        tr[u] = val[seq[r]];
        return;
    }
    int mid = (l + r) / 2;
    build(2 * u, l, mid);
    build(2 * u + 1, mid + 1, r);
    tr[u] = tr[2 * u + 1] * tr[2 * u];
}

int typ[maxn];

void del(int u, int f0, int f1){
    if (f0 == 0){
        c[u][1] -= 1;
    }
    else{
        h[u][1] = mul(h[u][1], qpow(f0, mod - 2));
    }
    int t = pls(f0, f1);
    if (t == 0){
        c[u][0] -= 1;
    }
    else{
        h[u][0] = mul(h[u][0], qpow(t, mod - 2));
    }
}

void add(int u, int f0, int f1){
    if (f0 == 0){
        c[u][1] += 1;
    }
    else{
        h[u][1] = mul(h[u][1], f0);
    }
    int t = pls(f0, f1);
    if (t == 0){
        c[u][0] += 1;
    }
    else{
        h[u][0] = mul(h[u][0], t);
    }
}

// 0 : 都可以 1 : 只能不选 2 : 只能选
void modify(int x, int type){
    typ[x] = type;
    if (type == 0){
        val[x].a[0][0] = (c[x][0] > 0 ? 0 : h[x][0]);
        val[x].a[0][1] = (c[x][1] > 0 ? 0 : h[x][1]);
        val[x].a[1][0] = (c[x][0] > 0 ? 0 : h[x][0]);
        val[x].a[1][1] = 0;
    }
    else if (type == 1){
        val[x].a[0][0] = (c[x][0] > 0 ? 0 : h[x][0]);
        val[x].a[0][1] = 0;
        val[x].a[1][0] = (c[x][0] > 0 ? 0 : h[x][0]);
        val[x].a[1][1] = 0;
    }
    else{
        val[x].a[0][0] = 0;
        val[x].a[0][1] = (c[x][1] > 0 ? 0 : h[x][1]);
        val[x].a[1][0] = 0;
        val[x].a[1][1] = 0;
    }
    while(x){
        ret.a[0] = 1, ret.a[1] = 0;
        query(1, 1, ts, in[top[x]], out[top[x]]);
        int f0 = ret.a[0], f1 = ret.a[1];
        modify(1, 1, ts, in[x], val[x]);
        ret.a[0] = 1, ret.a[1] = 0;
        query(1, 1, ts, in[top[x]], out[top[x]]);
        int f2 = ret.a[0], f3 = ret.a[1];
        x = fa[top[x]];
        if (x){
            del(x, f0, f1);
            add(x, f2, f3);
            if (typ[x] == 0){
                val[x].a[0][0] = (c[x][0] > 0 ? 0 : h[x][0]);
                val[x].a[0][1] = (c[x][1] > 0 ? 0 : h[x][1]);
                val[x].a[1][0] = (c[x][0] > 0 ? 0 : h[x][0]);
                val[x].a[1][1] = 0;
            }
            else if (typ[x] == 1){
                val[x].a[0][0] = (c[x][0] > 0 ? 0 : h[x][0]);
                val[x].a[0][1] = 0;
                val[x].a[1][0] = (c[x][0] > 0 ? 0 : h[x][0]);
                val[x].a[1][1] = 0;
            }
            else{
                val[x].a[0][0] = 0;
                val[x].a[0][1] = (c[x][1] > 0 ? 0 : h[x][1]);
                val[x].a[1][0] = 0;
                val[x].a[1][1] = 0;
            }
        }
    }
}

int cnt[maxn];

int main(){

#ifdef LOCAL
    freopen("data.in", "r", stdin);
    freopen("data.out", "w", stdout);
#endif

    cin.tie(0);
    cout.tie(0);
    ios::sync_with_stdio(0);

    int n, m;
    cin >> n >> m;
    vector<pair<int, int> > edge;
    for(int i = 1; i <= n; i++) p[i] = i;
    vector<int> p;
    for(int i = 1; i <= m; i++){
        int a, b;
        cin >> a >> b;
        if (merge(a, b)){
            g[a].push_back(b);
            g[b].push_back(a);
        }
        else{
            edge.push_back({a, b});
            p.push_back(a);
            p.push_back(b);
        }
    }
    sort(p.begin(), p.end());
    p.erase(unique(p.begin(), p.end()), p.end());
    dep[1] = 1;
    dfs_sz(1);
    top[1] = 1;
    dfs_hld(1);
    dfs(1);
    build(1, 1, ts);

    int ans = 0;
    
    // 容斥
    auto bf = [&](auto &&bf, int u, int sign) -> void {
        if (u == edge.size()){
            for(auto x : p){
                modify(x, cnt[x] ? 2 : 0);
            }
            ret.a[0] = 1, ret.a[1] = 0;
            query(1, 1, ts, in[1], out[1]);
            add(ans, mul(sign, ret.a[0]));
            add(ans, mul(sign, ret.a[1]));
            return;
        }
        auto [x, y] = edge[u];
        // 同时选
        {
            cnt[x] += 1;
            cnt[y] += 1;
            bf(bf, u + 1, mod - sign);
            cnt[x] -= 1;
            cnt[y] -= 1;
        }
        {
            bf(bf, u + 1, sign);
        }
    };

    bf(bf, 0, 1);
    cout << ans << '\n';

}