// ※※※ 解答不能 ※※※
// tourist氏.
// https://atcoder.jp/contests/cf17-relay-open/submissions/8930670
#include <bits/stdc++.h>
using namespace std;
#define repex(i, a, b, n) for(int i = a; i < b; i += n)
#define repx(i, a, b) repex(i, a, b, 1)
#define rep(i, n) repx(i, 0, n)
#define repr(i, a, b) for(int i = a; i >= b; i--)

template <typename A, typename B>
string to_string(pair<A, B> p);

template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);

template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s){ return '"' + s + '"'; }
string to_string(const char* s){ return to_string((string) s); }
string to_string(bool b){ return (b ? "true" : "false"); }
string to_string(vector<bool> v){
    bool first = true;
    string res = "{";
    rep(i, static_cast<int>(v.size())){
        if(!first) res += ", ";
        first = false;
        res += to_string(v[i]);
    }
    res += "}";
    return res;
}

template <size_t N>
string to_string(bitset<N> v){
    string res = "";
    for(size_t i = 0; i < N; i++) res += static_cast<char>('0' + v[i]);
    return res;
}

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

template <typename A, typename B>
string to_string(pair<A, B> p){ return "(" + to_string(p.first) + ", " + to_string(p.second) + ")"; }

template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p){
    return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}

template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p){
    return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}

void debug_out(){ cerr << endl; }

template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T){
    cerr << " " << to_string(H);
    debug_out(T...);
}

#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif

template <typename T>
T inverse(T a, T m){
    T u = 0, v = 1;
    while(a != 0){
        T t = m / a;
        m -= t * a; swap(a, m);
        u -= t * v; swap(u, v);
    }
    assert(m == 1);
    return u;
}

template <typename T>
class Modular{
public:
    using Type = typename decay<decltype(T::value)>::type;
    
    constexpr Modular() : value() {}
    template <typename U>
    Modular(const U& x){
        value = normalize(x);
    }
    
    template <typename U>
    static Type normalize(const U& x){
        Type v;
        if (-mod() <= x && x < mod()) v = static_cast<Type>(x);
        else v = static_cast<Type>(x % mod());
        if (v < 0) v += mod();
        return v;
    }
    
    const Type& operator()() const { return value; }
    template <typename U>
    explicit operator U() const { return static_cast<U>(value); }
    constexpr static Type mod() { return T::value; }
    
    Modular& operator+=(const Modular& other) { if ((value += other.value) >= mod()) value -= mod(); return *this; }
    Modular& operator-=(const Modular& other) { if ((value -= other.value) < 0) value += mod(); return *this; }
    template <typename U> Modular& operator+=(const U& other) { return *this += Modular(other); }
    template <typename U> Modular& operator-=(const U& other) { return *this -= Modular(other); }
    Modular& operator++() { return *this += 1; }
    Modular& operator--() { return *this -= 1; }
    Modular operator++(int) { Modular result(*this); *this += 1; return result; }
    Modular operator--(int) { Modular result(*this); *this -= 1; return result; }
    Modular operator-() const { return Modular(-value); }
    
    template <typename U = T>
    typename enable_if<is_same<typename Modular<U>::Type, int>::value, Modular>::type& operator*=(const Modular& rhs) {
#ifdef _WIN32
        uint64_t x = static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value);
        uint32_t xh = static_cast<uint32_t>(x >> 32), xl = static_cast<uint32_t>(x), d, m;
        asm(
            "divl %4; \n\t"
            : "=a" (d), "=d" (m)
            : "d" (xh), "a" (xl), "r" (mod())
        );
        value = m;
#else
        value = normalize(static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value));
#endif
        return *this;
    }
    template <typename U = T>
    typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value, Modular>::type& operator*=(const Modular& rhs){
        int64_t q = static_cast<int64_t>(static_cast<long double>(value) * rhs.value / mod());
        value = normalize(value * rhs.value - q * mod());
        return *this;
    }
    template <typename U = T>
    typename enable_if<!is_integral<typename Modular<U>::Type>::value, Modular>::type& operator*=(const Modular& rhs){
        value = normalize(value * rhs.value);
        return *this;
    }
    
    Modular& operator/=(const Modular& other){ return *this *= Modular(inverse(other.value, mod())); }
    
    template <typename U>
    friend const Modular<U>& abs(const Modular<U>& v){ return v; }
    
    template <typename U>
    friend bool operator==(const Modular<U>& lhs, const Modular<U>& rhs);
    
    template <typename U>
    friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs);
    
    template <typename U>
    friend std::istream& operator>>(std::istream& stream, Modular<U>& number);
    
private:
    Type value;
};

template <typename T> bool operator==(const Modular<T>& lhs, const Modular<T>& rhs){ return lhs.value == rhs.value; }
template <typename T, typename U> bool operator==(const Modular<T>& lhs, U rhs){ return lhs == Modular<T>(rhs); }
template <typename T, typename U> bool operator==(U lhs, const Modular<T>& rhs){ return Modular<T>(lhs) == rhs; }

template <typename T> bool operator!=(const Modular<T>& lhs, const Modular<T>& rhs){ return !(lhs == rhs); }
template <typename T, typename U> bool operator!=(const Modular<T>& lhs, U rhs){ return !(lhs == rhs); }
template <typename T, typename U> bool operator!=(U lhs, const Modular<T>& rhs){ return !(lhs == rhs); }

template <typename T> bool operator<(const Modular<T>& lhs, const Modular<T>& rhs){ return lhs.value < rhs.value; }

template <typename T> Modular<T> operator+(const Modular<T>& lhs, const Modular<T>& rhs){ return Modular<T>(lhs) += rhs; }
template <typename T, typename U> Modular<T> operator+(const Modular<T>& lhs, U rhs){ return Modular<T>(lhs) += rhs; }
template <typename T, typename U> Modular<T> operator+(U lhs, const Modular<T>& rhs){ return Modular<T>(lhs) += rhs; }

template <typename T> Modular<T> operator-(const Modular<T>& lhs, const Modular<T>& rhs){ return Modular<T>(lhs) -= rhs; }
template <typename T, typename U> Modular<T> operator-(const Modular<T>& lhs, U rhs){ return Modular<T>(lhs) -= rhs; }
template <typename T, typename U> Modular<T> operator-(U lhs, const Modular<T>& rhs){ return Modular<T>(lhs) -= rhs; }

template <typename T> Modular<T> operator*(const Modular<T>& lhs, const Modular<T>& rhs){ return Modular<T>(lhs) *= rhs; }
template <typename T, typename U> Modular<T> operator*(const Modular<T>& lhs, U rhs){ return Modular<T>(lhs) *= rhs; }
template <typename T, typename U> Modular<T> operator*(U lhs, const Modular<T>& rhs){ return Modular<T>(lhs) *= rhs; }

template <typename T> Modular<T> operator/(const Modular<T>& lhs, const Modular<T>& rhs){ return Modular<T>(lhs) /= rhs; }
template <typename T, typename U> Modular<T> operator/(const Modular<T>& lhs, U rhs){ return Modular<T>(lhs) /= rhs; }
template <typename T, typename U> Modular<T> operator/(U lhs, const Modular<T>& rhs){ return Modular<T>(lhs) /= rhs; }

template<typename T, typename U>
Modular<T> power(const Modular<T>& a, const U& b){
    assert(b >= 0);
    Modular<T> x = a, res = 1;
    U p = b;
    while(p > 0){
        if (p & 1) res *= x;
        x *= x;
        p >>= 1;
    }
    return res;
}

template <typename T>
bool IsZero(const Modular<T>& number){ return number() == 0; }

template <typename T>
string to_string(const Modular<T>& number){ return to_string(number()); }

template <typename T>
std::ostream& operator<<(std::ostream& stream, const Modular<T>& number){ return stream << number(); }

template <typename T>
std::istream& operator>>(std::istream& stream, Modular<T>& number){
    typename common_type<typename Modular<T>::Type, int64_t>::type x;
    stream >> x;
    number.value = Modular<T>::normalize(x);
    return stream;
}

/*
using ModType = int;

struct VarMod { static ModType value; };
ModType VarMod::value;
ModType& md = VarMod::value;
using Mint = Modular<VarMod>;
*/

constexpr int md = (int) 1e9 + 7;
using Mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>;

int main(){
    int n, m;
    scanf("%d %d", &n, &m);
    vector<int> g(n);
    rep(i, m){
        int x, y;
        scanf("%d %d", &x, &y);
        --x; --y;
        g[x] |= 1 << y;
        g[y] |= 1 << x;
    }
    vector<Mint> pinv2(n * n + 1);
    pinv2[0] = 1;
    repx(i, 1, (int)pinv2.size()) pinv2[i] = pinv2[i - 1] / 2;
    vector<vector<Mint>> p(2, vector<Mint>(1 << n));
    rep(v, 2){
        rep(t, 1 << n){
            if(t & (1 << v)){
                p[v][t] = 1;
                int u = t;
                while(u > 0){
                    u = (u - 1) & t;
                    if(u & (1 << v)){
                        int c = 0;
                        rep(i, n){
                            if(u & (1 << i)) c += __builtin_popcount(t & ~u & g[i]);
                        }
                        p[v][t] -= p[v][u] * pinv2[c];
                    }
                }
            }
        }
    }
    Mint ans = 1;
    repx(t, 1, 1 << n){
        if(t & 1){
            int u = (1 << n) - 1 - t;
            while(u > 0){
                if(u & 2){
                    bool ok = true;
                    rep(i, n){
                        if((t & (1 << i)) && (u & g[i])){
                            ok = false;
                            break;
                        }
                    }
                    if(ok){
                        int c = 0;
                        rep(i, n){
                            if((t | u) & (1 << i)) c += __builtin_popcount(~t & ~u & g[i]);
                        }
                        ans -= p[0][t] * p[1][u] * pinv2[c];
                    }
                }
                u = (u - 1) & ((1 << n) - 1 - t);
            }
        }
    }
    ans *= power(Mint(2), m);
    printf("%lld\n", ans);
    return 0;
}

Measured memory_bytes: 640