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: Accepted)

#include <bits/stdc++.h>

#define mp make_pair
#define pb push_back
#define x first
#define y second
#define DEBUG(x) cout << #x << " = " << x << endl;

using namespace std;

typedef long long LL;
typedef unsigned long long ull;
typedef pair<int, int> pii;

const int inf = INT_MAX;
const LL INF = LLONG_MAX;

template <typename T> inline int chkmax (T &a, T b) { return a < b ? a = b, 1 : 0; }
template <typename T> inline int chkmin (T &a, T b) { return a > b ? a = b, 1 : 0; }

template <typename T> inline T read ()
{
	T sum = 0, fl = 1; char ch = getchar();
	for (; !isdigit(ch); ch = getchar()) if (ch == '-') fl = -1;
	for (; isdigit(ch); ch = getchar()) sum = (sum << 3) + (sum << 1) + (ch - '0');
	return sum * fl;
}

const int maxn = 15;
const int mod = 1e9 + 7;

int N, M;
int E[maxn + 1];

inline void add (int &x, int y) { x = x + y >= mod ? x + y - mod : x + y; }

inline void solve ()
{
	static int F[1 << maxn], pw[maxn * maxn + 1], cnt[1 << maxn];

	pw[0] = 1; F[0] = 1;
	for (int i = 1; i <= M; ++i) pw[i] = 2ll * pw[i - 1] % mod;
	for (int i = 1; i < (1 << N); ++i) cnt[i] = __builtin_popcount (i);
	
	for (int i = 1; i < (1 << N); ++i)
	{
		for (int S = i; S > 0; S = (S - 1) & i) //SG = 0的集合
		{
			if ((S & 3) != 0 && (S & 3) != 3) continue; //1,2要在一起

			int sum = 0, least = 1, T = i - S;	
			for (int k = 1; k <= N; ++k) 
			{
				if ((S >> k - 1) & 1) sum += cnt[E[k] & T]; //S 到 T 随便连边
				if ((T >> k - 1) & 1) least = (LL)least * (pw[cnt[E[k] & S]] - 1) % mod;//T 每个点到 S 至少要有一条边 
			}

			add (F[i], (LL)F[T] * pw[sum] % mod * least % mod);
		}
	}

	printf ("%d\n", (pw[M] - F[(1 << N) - 1] + mod) % mod);
}

inline void input ()
{
	N = read<int>(), M = read<int>();
	for (int i = 1; i <= M; ++i) 
	{
		int x = read<int>(), y = read<int>();
		E[x] |= 1 << y - 1;
	}
}

int main ()
{


	input ();
    solve ();

    return 0;
}