#include <bits/stdc++.h>

#define lsb(x) (x & (-x))

using ull = unsigned long long;
using ll = long long;

using namespace std;

constexpr int MOD = (int) 1e9 + 7;
constexpr int MAXN = 1000;

bitset<MAXN + 1> adj[MAXN + 1];

inline void add(int& x, int y) {
    x += y;
    if (x >= MOD)
        x -= MOD;
}

int main() {
#ifdef HOME
    ifstream cin("input.in");
    ofstream cout("output.out");
#endif
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);

    int n, m;
    cin >> n >> m;

    vector<pair<int, int>> edges;
    vector<int> deg(n + 1);
    for (int i = 0; i < m; i++) {
        int x, y;
        cin >> x >> y;
        edges.emplace_back(x, y);
        deg[x]++, deg[y]++;
    }

    vector<int> order(n);
    iota(order.begin(), order.end(), 1);
    sort(order.begin(), order.end(), [&](const int& x, const int& y) {
        return deg[x] < deg[y];
    });

    vector<int> where(n + 1);
    for (int i = 0; i < n; i++) {
        where[order[i]] = i;
    }

    vector<vector<int>> g(n + 1);
    for (auto edge : edges) {
        int x = edge.first, y = edge.second;
        if (where[x] > where[y]) {
            swap(x, y);
        }
        g[x].push_back(y);
        adj[x][y] = adj[y][x] = 1;
    }

    for (int i = 1; i <= n; i++) {
        adj[i][i] = true;
    }

    int answer = 0;
    for (auto x : order) {
        vector<int> neis;
        for (auto itr : g[x]) {
            neis.push_back(itr);
        }
        sort(neis.begin(), neis.end(), [&](const int& x, const int& y) {
            return where[x] < where[y];
        });

        vector<ll> masks(neis.size());
        for (int i = 0; i < (int)neis.size(); i++) {
            for (int j = 0; j < (int)neis.size(); j++) {
                if (adj[neis[i]][neis[j]]) {
                    masks[i] |= (1LL << j);
                }
            }
        }

        int size1 = (int)neis.size() / 2;
        int size2 = (int)neis.size() - size1;
        vector<int> dp(1 << size2);
       
        for (int mask = 0; mask < (1 << size2); mask++) {
            bool ok = true;
            for (int bit = 0; bit < size2 && !ok; bit++) {
                if (mask & (1 << bit)) {
                    if (((masks[bit + size1] >> size1) & mask) != mask) {
                        ok = false;
                    }
                }
            }
            if (ok) {
                add(dp[mask], 1);
            }
        }

        for (int bit = 0; bit < size2; bit++) {
            for (int mask = 0; mask < (1 << size2); mask++) {
                if (mask & (1 << bit)) {
                    add(dp[mask], dp[mask ^ (1 << bit)]);
                }
            }
        }

        for (int mask = 0; mask < (1 << size1); mask++) {
            ll m = (1LL << (size1 + size2)) - 1;
            bool ok = true;
            for (int bit = 0; bit < size1; bit++) {
                if (mask & (1 << bit)) {
                    m &= masks[bit];
                }
            }
            if ((mask & m) == mask) {
                add(answer, dp[m >> size1]);
            }
        }
    }

    cout << answer;

    return 0;
}