Problem:
Score : 1600 points

Problem Statement

There is a directed graph G with N vertices and M edges.
The vertices are numbered 1 through N, and the edges are numbered 1 through M.
Edge i is directed from x_i to y_i.
Here, x_i < y_i holds.
Also, there are no multiple edges in G.

Consider selecting a subset of the set of the M edges in G, and removing these edges from G to obtain another graph G'.
There are 2^M different possible graphs as G'.

Alice and Bob play against each other in the following game played on G'.
First, place two pieces on vertices 1 and 2, one on each.
Then, starting from Alice, Alice and Bob alternately perform the following operation:

Select an edge i such that there is a piece placed on vertex x_i, and move the piece to vertex y_i (if there are two pieces on vertex x_i, only move one). The two pieces are allowed to be placed on the same vertex.

The player loses when he/she becomes unable to perform the operation.
We assume that both players play optimally.

Among the 2^M different possible graphs as G', how many lead to Alice's victory?
Find the count modulo 10^9+7.

Constraints

2 ≤ N ≤ 15

1 ≤ M ≤ N(N-1)/2

1 ≤ x_i < y_i ≤ N

All (x_i,\ y_i) are distinct.

Input

Input is given from Standard Input in the following format:

N M
x_1 y_1
x_2 y_2
:
x_M y_M

Output

Print the number of G' that lead to Alice's victory, modulo 10^9+7.

Sample Input 1

2 1
1 2

Sample Output 1

1

The figure below shows the two possible graphs as G'.
A graph marked with ○ leads to Alice's victory, and a graph marked with × leads to Bob's victory.

Sample Input 2

3 3
1 2
1 3
2 3

Sample Output 2

6

The figure below shows the eight possible graphs as G'.

Sample Input 3

4 2
1 3
2 4

Sample Output 3

2

Sample Input 4

5 10
2 4
3 4
2 5
2 3
1 2
3 5
1 3
1 5
4 5
1 4

Sample Output 4

816

Solution in C++14 (GCC 5.4.1) (judge verdict: Time Limit Exceeded)

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cassert>
#include <cctype>
#include <algorithm>
#include <functional>
#include <utility>
#include <vector>
#include <queue>
#include <map>
#include <unordered_map>
using ll = long long;
const ll ha = 1000000007;
const int maxs = 1 << 15 | 1;
const int N = 100000;
ll tpow[N + 5];
int n; int pcnt[maxs];
inline void process() {
  tpow[0] = 1;
  for(int i = 1; i <= N; i ++) {
    tpow[i] = (tpow[i - 1] << 1) % ha;
  }
  pcnt[0] = 0;
  for(int i = 1; i < (1 << n); i ++) {
    pcnt[i] = pcnt[i & (i - 1)] + 1;
  }
}

std::map<int, ll> ma[maxs];
std::map<int, ll> ma_xy[maxs];
int G[20];
inline void add_edge(int u, int v) {
  G[u] |= (1 << (v - 1));
}
inline void process_ma() {
  const int al_S = (1 << n) - 1;
  for(int s = 0; s < (1 << n); s ++) {
    const int bs = s ^ al_S;
    for(int t = bs; t; t = (t - 1) & bs) {
      if((s & 3) && (t & 3)) continue;
      ll ans = 1, ans_2 = 1;
      for(int i = 1; i <= n; i ++) {
        if((1 << (i - 1)) & s) {
          const ll th = tpow[pcnt[t & G[i]]] - 1;
          ans = (ans * th) % ha;
        }
        if((1 << (i - 1)) & t) {
          const ll th = tpow[pcnt[s & G[i]]];
          ans_2 = ans_2 * th % ha;
        }
      }
      ma[s][t] = ans;
      ma_xy[s][t] = ans_2;
#ifdef LOCAL
      printf("Edge(lim) from %d to %d : %lld\n", s, t, ans);
      printf("Edge from %d to %d : %lld\n", t, s, ans_2);
#endif
    }
  }
}

ll f[maxs];
ll dp(int s) {
  if(!s) return 1;
  ll &ans = f[s];
  if(ans != -1LL) return ans;
  ans = 0;
  for(int t = s; t; t = (t - 1) & s) {
    const int y = s ^ t;
    if((t & 3) && (y & 3)) continue;
    const ll xi = ma[y][t] * ma_xy[y][t] % ha;
    ans = (ans + xi * dp(y)) % ha;
  }
#ifdef LOCAL
  printf("f[%d] : %lld\n", s, ans);
#endif
  return ans;
}

int main() {
  int m; scanf("%d%d", &n, &m);
  for(int i = 1; i <= m; i ++) {
    int u, v; scanf("%d%d", &u, &v);
    add_edge(u, v);
  }
  process(); process_ma();
  memset(f, 0xff, sizeof(f));
  printf("%lld\n", (tpow[m] - dp((1 << n) - 1) + ha) % ha);
  return 0;
}