#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 dp[1 << 18];
ll mask1[1 << 18], mask2[1 << 18];

int lg[(1 << 18) + 1];

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

    for (int i = 2; i <= (1 << 18); i <<= 1) {
        lg[i] = lg[i >> 1] + 1;
    }

    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) {
        sort(g[x].begin(), g[x].end(), [&](const int& x, const int& y) {
            return where[x] < where[y];
        });

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

        int size1 = (int)g[x].size() / 2;
        int size2 = (int)g[x].size() - size1;

        mask1[0] = mask2[0] = (1LL << (size1 + size2)) - 1;
        for (int i = 0; i < (1 << size2); i++) {
            dp[i] = 0;
        }

        dp[0] = 1;
        for (int mask = 1; mask < (1 << size2); mask++) {
            int bit = lg[lsb(mask)];
            mask2[mask] = (mask2[mask ^ (1 << bit)] & masks[bit + size1]);
            if (((mask2[mask] >> size1) & mask) == mask) {
                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++) {
            int bit = lg[lsb(mask)];
            if (mask == 0) {
                mask1[mask] = (1LL << (size1 + size2)) - 1;
            } else {
                mask1[mask] = (mask1[mask ^ (1 << bit)] & masks[bit]);
            }
            if ((mask & mask1[mask]) == mask) {
                add(answer, dp[mask1[mask] >> size1]);
            }
        }
    }

    cout << answer;

    return 0;
}