#include<bits/stdc++.h>
template <const unsigned Md> struct modint {
private:
  template <class T>
  using must_int = std::enable_if_t<std::is_integral<T>::value> *;
  struct Mongomery {
    typedef unsigned int uint;
    typedef unsigned long long ull;
    uint mod, niv, R;
    Mongomery() {}
    constexpr Mongomery(const uint &m) : mod(m), niv(m + 2), R((-(ull)m) % m) {
      for (int i = 0; i < 4; i++)
        niv *= (m * niv + 2);
    }
    uint reduce(ull x) const {
      x = ((x + (ull)((uint)x * niv) * mod) >> 32);
      return (x >= mod) ? x - mod : x;
    }
  };
  typedef unsigned int uint;
  typedef unsigned long long ull;
  const static int mod = Md;
  const static unsigned umod = Md;
  const static constexpr Mongomery mont = Mongomery(Md);

public:
  unsigned val;
  modint() : val(0) {}
  modint(unsigned x) : val(mont.reduce((ull)x * mont.R)) {}
  template <class T, must_int<T> = nullptr>
  modint(T x) : modint((unsigned)(x %= mod, x < 0 ? x + mod : x)) {}
  friend int value(const modint &self) { return mont.reduce(self.val); }
  int value() { return mont.reduce(val); }
  modint operator+() { return *this; }
  modint operator-() { return modint() - *this; }
  modint &operator+=(const modint &rhs) {
    val += rhs.val;
    if (val >= umod)
      val -= umod;
    return *this;
  }
  modint &operator-=(const modint &rhs) {
    val -= rhs.val;
    if (val >= umod)
      val += umod;
    return *this;
  }
  modint &operator*=(const modint &rhs) {
    val = mont.reduce((ull)val * rhs.val);
    return *this;
  }
  friend modint qpow(modint a, ull b) {
    modint s(1);
    while (b) {
      if (b & 1)
        s *= a;
      a *= a;
      b >>= 1;
    }
    return s;
  }
  modint &operator/=(const modint &rhs) { return *this *= qpow(rhs, umod - 2); }
  friend modint operator+(modint lhs, const modint &rhs) { return lhs += rhs; }
  friend modint operator-(modint lhs, const modint &rhs) { return lhs -= rhs; }
  friend modint operator*(modint lhs, const modint &rhs) { return lhs *= rhs; }
  friend modint operator/(modint lhs, const modint &rhs) { return lhs /= rhs; }
  bool operator==(const modint &rhs) const { return val == rhs.val; }
  bool operator!=(const modint &rhs) const { return val != rhs.val; }
  modint &operator++() { return *this += modint(1); }
  modint &operator--() { return *this -= modint(1); }
  modint operator++(int) {
    modint tmp = *this;
    ++(*this);
    return tmp;
  }
  modint operator--(int) {
    modint tmp = *this;
    --(*this);
    return tmp;
  }
};
#define For(i,j,k) for(int i=(j);i<=(k);++i)
#define ForDown(i,j,k) for(int i=(j);i>=(k);--i)
#define Debug(fmt, args...) fprintf(stderr,"(func %s, line #%d): " fmt,__func__,__LINE__,##args),fflush(stderr)
#define debug(fmt, args...) fprintf(stderr,fmt,##args),fflush(stderr)
#define within :
#define LJY main
using namespace std;
typedef long long ll;
const int mod=1e9+7,N=15;
using mint=modint<mod>;
mt19937 rnd(chrono::system_clock::now().time_since_epoch().count());
inline int read(){
  char ch=getchar();int x=0,f=1;
  while(ch<'0'||ch>'9'){if(ch=='-') f=-1;ch=getchar();}
  while(ch>='0'&&ch<='9')
    x=(x<<3)+(x<<1)+(ch^48),ch=getchar();
  return x*f;
}
int n,m,in[N],out[N],cnt[1<<N],pcnt[1<<N],del[1<<N];
mint pw[N*N],f[1<<N],g[1<<N];
void calc(int T,int S){
  if((T-1)&S) calc((T-1)&S,S);
  del[T]=del[T&(T-1)]+pcnt[in[__lg(T&-T)]&S];
}
signed LJY(){
  n=read();m=read();pw[0]=1;
  For(i,1,m){
    int u=read()-1,v=read()-1;
    in[v]|=(1<<u);out[u]|=(1<<v);pw[i]=pw[i-1]+pw[i-1];
  }For(S,1,(1<<n)-1){
    int bt=__lg(S&-S);pcnt[S]=__builtin_popcount(S);
    cnt[S]=cnt[S&(S-1)]+pcnt[in[bt]&S]+pcnt[out[bt]&S];
  }For(S,1,(1<<n)-1){
    calc(S,S);f[S]=pw[cnt[S]];
    int T=S&(S-1);
    for(int i=(S-1)&S;i;i=(i-1)&T) g[S]-=g[i]*f[S^i];
    for(int i=S;i;i=(i-1)&S) f[S]-=g[i]*pw[cnt[S]-del[i]];
    g[S]+=f[S];
  }printf("%d",value(f[(1<<n)-1]));
  return 0;
}