/// @author Camillus <3
#include "bits/stdc++.h"

using ull = unsigned long long;
using namespace std;

struct mint {
    static constexpr int mod = 998'244'353;
    int value = 0;

    mint() = default;
    mint(int value) : value(value) {}

    mint& operator+=(const mint &other) {
        value += other.value;
        if (value >= mod) {
            value -= mod;
        }
        return *this;
    }

    mint operator+(const mint &other) const {
        return mint(value) += other;
    }

    mint& operator-=(const mint &other) {
        value += mod - other.value;
        if (value >= mod) {
            value -= mod;
        }
        return *this;
    }

    mint operator-(const mint &other) const {
        return mint(value) -= other;
    }

    mint &operator*=(const mint &other) {
        value = 1ll * value * other.value % mod;
        return *this;
    }

    mint operator*(const mint &other) const {
        return mint(value) *= other;
    }

    mint power(int k) const {
        mint result = 1;
        mint current = *this;

        while (k) {
            if (k & 1) {
                result *= current;
            }
            current *= current;
            k >>= 1;
        }

        return result;
    }

    mint &operator/=(const mint &other) {
        return this->operator*=(other.power(mod - 2));
    }

    mint operator/(const mint &other) const {
        return mint(value) /= other;
    }

    friend ostream& operator<<(ostream &out, const mint &other) {
        return out << other.value;
    }

    friend istream& operator>>(istream &in, mint &other) {
        return in >> other.value;
    }
};

vector<int> g[18];

unordered_map<ull, mint> saved;

int n;

mint calc(ull maskA, ull maskB) {
    if (maskA == (1 << n) - 1 && maskB == 0) {
        return 1;
    } else if (maskB == 0) {
        return 0;
    }

    if (saved.contains(maskA << n | maskB)) {
        return saved[maskA << n | maskB];
    }

    bitset<18> A(maskA);
    bitset<18> B(maskB);

    mint sum = 0;

    for (int u = 0; u < n; u++) {
        if (B[u]) {
            B[u] = false;
            auto Ap = A;
            Ap[u] = true;

            auto Bp = B;

            for (int v : g[u]) {
                if (!A[v]) {
                    Bp[v] = true;
                }
            }

            sum += calc(Ap.to_ullong(), Bp.to_ullong());
        }
    }

    return saved[maskA << n | maskB] = sum;
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    saved.reserve(1e5);

    int m;
    cin >> n >> m;

    for (int i = 0; i < m; i++) {
        int u, v;
        cin >> u >> v;

        u--, v--;

        g[u].push_back(v);
        g[v].push_back(u);
    }

    cout << calc(0, (1 << n) - 1) / 2 << '\n';
    return 0;
}