Problem: Consider a closed world and a set of features that are defined for all the objects in the world. Each feature can be answered with "yes" or "no". Using those features, we can identify any object from the rest of the objects in the world. In other words, each object can be represented as a fixed-length sequence of booleans. Any object is different from other objects by at least one feature.

You would like to identify an object from others. For this purpose, you can ask a series of questions to someone who knows what the object is. Every question you can ask is about one of the features. He/she immediately answers each question with "yes" or "no" correctly. You can choose the next question after you get the answer to the previous question.

You kindly pay the answerer 100 yen as a tip for each question. Because you don' t have surplus money, it is necessary to minimize the number of questions in the worst case. You don’t know what is the correct answer, but fortunately know all the objects in the world. Therefore, you can plan an optimal strategy before you start questioning.

The problem you have to solve is: given a set of boolean-encoded objects, minimize the maximum number of questions by which every object in the set is identifiable.



Input

The input is a sequence of multiple datasets. Each dataset begins with a line which consists of two integers, m and n: the number of features, and the number of objects, respectively. You can assume 0 < m ≤ 11 and 0 < n ≤ 128. It is followed by n lines, each of which corresponds to an object. Each line includes a binary string of length m which represent the value ("yes" or "no") of features. There are no two identical objects.

The end of the input is indicated by a line containing two zeros. There are at most 100 datasets.

Output

For each dataset, minimize the maximum number of questions by which every object is identifiable and output the result.

Example

Input

8 1
11010101
11 4
00111001100
01001101011
01010000011
01100110001
11 16
01000101111
01011000000
01011111001
01101101001
01110010111
01110100111
10000001010
10010001000
10010110100
10100010100
10101010110
10110100010
11001010011
11011001001
11111000111
11111011101
11 12
10000000000
01000000000
00100000000
00010000000
00001000000
00000100000
00000010000
00000001000
00000000100
00000000010
00000000001
00000000000
9 32
001000000
000100000
000010000
000001000
000000100
000000010
000000001
000000000
011000000
010100000
010010000
010001000
010000100
010000010
010000001
010000000
101000000
100100000
100010000
100001000
100000100
100000010
100000001
100000000
111000000
110100000
110010000
110001000
110000100
110000010
110000001
110000000
0 0


Output

0
2
4
11
9

Solution (in CPP):

Solution:
/* 
   x日間悩み、
   動的計画法でやろうということを思いついた。
   数学的に解が得られる方法は複数ありうる。
   しかし、0 < m \leq 11 and 0 < n \leq 128 という制約の中で
   制限に引っかからなそうなものとなると、状態の持ち方が限られる。
   
   たとえば自然な発想として、
   「n個のonjectの各部分集合を状態として持ち、それを類別するために必要な最小の
   質問回数」を配列で持とうとするものが考えられる。
   しかし2^{128}個のintはメモリの上においておくのは無理である。
   よく考えてみると相当無駄がある。質問はm \leq 11個しかない
   だから「出てきうる」部分集合の個数は、せいぜい3^{11}個であり、2^{128}より
   はるかに少ない。
   
   そこで、
   「m個の質問それぞれを『未回答』『はい』『いいえ』をみたす
   onjectの集合を状態として持ち、それを類別するために必要な最小の
   質問回数」を配列で持とう。これなら3^{11}個である。
   (ただし以下の実装の2次元配列のサイズは2^{11} \times 2^{11}である)
   
   次なる問題はどのようにしてこの動的計画法を進めるかである。
   ここでさらにy日悩んだが、
   「集合の元の数が1個か0個」は0とし、
   あとは深さ優先探索を併用している。
   完全に再帰でやるとメモリ足りないかもしれないので、
   『未回答』が少ない集合からまわしていき、
   あまり深すぎないように努力した。
 */

#include <iostream>
#include <vector>
#include <cassert>
#include <string>
using namespace std;

vector< vector<int> > V; // [0:未回答 1:回答済み][0:Yes 1:No]
int n, m, C;
vector<int> W;
const int infty = 1000;
vector< vector<int> > X; // X[i] = i個bitが立っている集合

void init() {
  C = (1 << m);
  V.clear();
  V = vector< vector<int> >(C, vector<int>(C, infty));
  W.clear();
  for (auto i=0; i<n; i++) {
    long long w;
    string s;
    cin >> s;
    w = stoll(s);
    int x = 0;
    int y = 1;
    for (auto j=0; j<m; j++) {
      x += w%10 * y;
      y *= 2;
      w /= 10;
    }
    // cerr << x << endl;
    W.push_back(x);
  }
  X.clear();
  X = vector< vector<int> >(m+1, vector<int>(0));
  for (auto i=0; i<C; i++) {
    int count = 0;
    for (auto k=0; k<m; k++) {
      if ((i >> k) & 1) {
	count++;
      }
    }
    X[count].push_back(i);
    // cerr << "X[" << count << "] pushed " << i << endl; 
  }
}

bool ok(int i, int j) { // 未回答なのにjに1が立っているものを弾く
  for (auto k=0; k<m; k++) {
    if ( ((j >> k) & 1) && (((i >> k) & 1) == 0) ) {
      return false;
    }
  }
  return true;
}

void costzero() {
  for(auto i=0; i<C; i++) {
    for (auto j=0; j<C; j++) {
      if (ok(i, j)) {
	// cerr << "i = " << i << ", j = " << j << endl;
	vector<int> K = W;
	for (auto k=0; k<m; k++) {
	  if ((i >> k) & 1) {
	    vector<int> L;
	    int x = (j >> k) & 1;
	    for (unsigned int l=0; l<K.size(); l++) {
	      if (((K[l] >> k) & 1) == x) {
		L.push_back(K[l]);
	      }
	    }
	    K.clear();
	    K = L;
	  }
	}
	// cerr << K.size() << endl;
	if (K.size() <= 1) {
	  V[i][j] = 0;
	  // cerr << "i = " << i << ", j = " << j << endl;
	}
      }
    }
  }
}

int cost(int i, int j) {
  if (V[i][j] < infty) {
    return V[i][j];
  }
  int ans = infty;
  for (auto k=0; k<m; k++) {
    if (((i >> k) & 1) == 0) {
      int ansk = 0;
      int ni = i | (1 << k);
      for (auto l=0; l<2; l++) {
	int nj = j | (l << k);
	int anskl = cost(ni, nj);
	if (ansk < anskl) ansk = anskl;
      }
      if (ans > ansk) ans = ansk;
    }
  }
  if (ans == infty) {
    cerr << "infty i = " << i << " j = " << j << endl;
  }
  assert(ans < infty);
  ans++;
  V[i][j] = ans;
  return ans;
}

int main() {
  while(cin >> m >> n && m) {
    init();
    costzero();
    for (int i=m; i>=0; i--) {
      for (unsigned int j=0; j<X[i].size(); j++) {
	for (auto k=0; k<C; k++) {
	  if (ok(X[i][j], k)) {
	    cost(X[i][j], k);
	  }
	}
      }
    }
    cout << cost(0, 0) << endl;
  }
}