#include <bits/stdc++.h>
using namespace std;

template <class T> int sz(T&& a) { return int(size(forward<T>(a))); }

template <class T> using vc = vector<T>;
template <class T> using vvc = vc<vc<T>>;

using ll = int64_t;
using vi = vc<int>;
using uint = uint32_t;
using ull = uint64_t;

template <class F>
struct ycr {
	F f;
	
	template <class T>
	explicit ycr(T&& f_) : f(forward<T>(f_)) {}

	template <class... Args>
	decltype(auto) operator()(Args&&... args) {
		return f(ref(*this), forward<Args>(args)...);
	}
};
template <class F>
decltype(auto) yc(F&& f) {
	return ycr<decay_t<F>>(forward<F>(f));
}

template <class T> T pow(T a, ll b) {
	assert(b >= 0);
	T r = 1;
	while (b) {
		if (b & 1) r *= a;
		b >>= 1, a *= a;
	}
	return r;
}

template <uint mod> struct mint {
	static constexpr uint m = mod;

	uint v;
	mint() : v(0) {}
	mint(ll a) { s(uint(a % m + m)); }
	mint& s(uint a) { v = a < m ? a : a-m; return *this; }

	mint operator- () const {
		mint res;
		res.v = v ? m-v : 0;
		return res;
	}
	friend mint inv(const mint& n) { return pow(n, m-2); }

	mint& operator += (const mint& o) { return s(v + o.v); return *this; }
	mint& operator -= (const mint& o) { return s(v + m - o.v); return *this; }
	mint& operator *= (const mint& o) { v = uint(ull(v) * o.v % m); return *this; }
	mint& operator /= (const mint& o) { return v *= inv(o); }

	friend mint operator + (const mint& a, const mint& b) { return mint(a) += b; }
	friend mint operator - (const mint& a, const mint& b) { return mint(a) -= b; }
	friend mint operator * (const mint& a, const mint& b) { return mint(a) *= b; }
	friend mint operator / (const mint& a, const mint& b) { return mint(a) /= b; }
};

int main() {
	ios_base::sync_with_stdio(false), cin.tie(nullptr);
	cout << fixed << setprecision(20);

	int N, D; cin >> N >> D;
	constexpr int L = 16;
	using num = mint<int(1e9) + 7>;
	// lower bits: sum
	// higher bits: fixed
	vector<num> dp(1 << L);
	for (int m = 0; m < (1 << (L/2)); m++) {
		dp[m + (0 << (L/2))] = 1;
	}
	for (int i = 0; i < N; i++) {
		int a;
		{
			string s; cin >> s;
			a = 0;
			for (int j = 0; j < D; j++) {
				if (s[j] == '1') a += (1 << j);
			}
		}
		const int lower = a & ((1 << (L/2)) - 1);
		const int higher = (a >> (L/2));
		num v;
		{
			v = 0;
			int cur_higher = higher;
			while (true) {
				v += dp[lower + (cur_higher << (L/2))];
				if (cur_higher == 0) break;
				cur_higher = (cur_higher-1) & higher;
			}
		}
		{
			const int lower_comp = (1 << (L/2)) - 1 - lower;
			int cur_lower = lower_comp;
			while (true) {
				dp[lower + cur_lower + (higher << (L/2))] += v;
				if (cur_lower == 0) break;
				cur_lower = (cur_lower-1) & lower_comp;
			}
		}
	}

	num ans = 0;
	for (int higher = 0; higher < (1 << (L/2)); higher++) {
		ans += dp[(1 << (L/2)) - 1 + (higher << (L/2))];
	}
	ans -= 1;
	cout << ans.v << '\n';
}