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

#define ll long long
#define elif else if
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define pii pair<int,int>


#define repname(a, b, c, d, e, ...) e
#define rep(...)                    repname(__VA_ARGS__, rep3, rep2, rep1, rep0)(__VA_ARGS__)
#define rep0(x)                     for (int rep_counter = 0; rep_counter < (x); ++rep_counter)
#define rep1(i, x)                  for (int i = 0; i < (x); ++i)
#define rep2(i, l, r)               for (int i = (l); i < (r); ++i)
#define rep3(i, l, r, c)            for (int i = (l); i < (r); i += (c))





struct ScalarInput {
    template<class T>
    operator T(){
        T ret;
        cin >> ret;
        return ret;
    }
};
struct VectorInput {
    size_t n;
    VectorInput(size_t n): n(n) {}
    template<class T>
    operator vector<T>(){
        vector<T> ret(n);
        for(T &x : ret) cin >> x;
        return ret;
    }
};
ScalarInput input(){ return ScalarInput(); }
VectorInput input(size_t n){ return VectorInput(n); }

template<typename T>
void print(vector<T> a){
  for(int i=0;i<a.size();i++){
    cout<<a[i]<<" \n"[i+1==a.size()];
  }
}

template<class T>
void print(T x){
    cout << x << '\n';
}
 
template <class Head, class... Tail>
void print(Head&& head, Tail&&... tail){
  cout << head << ' ';
  print(forward<Tail>(tail)...);
}

vector<int>Log2(1e6+10);


class Cum2D {
public:
    Cum2D(int h, int w, const std::vector<std::vector<int>>& a) : h(h), w(w) {
        cum.assign(h + 1, std::vector<int>(w + 1, 0));
        
        for (int i = 0; i < h; ++i) {
            for (int j = 0; j < w; ++j) {
                cum[i + 1][j + 1] = a[i][j] + cum[i + 1][j];
            }
        }
        
        for (int j = 0; j < w; ++j) {
            for (int i = 0; i < h; ++i) {
                cum[i + 1][j + 1] += cum[i][j + 1];
            }
        }
    }
    
    int query(int x1, int y1, int x2, int y2) const {
        if (x1 > x2 || y1 > y2) {
            return 0;
        }
        return cum[x2 + 1][y2 + 1] - cum[x2 + 1][y1] - cum[x1][y2 + 1] + cum[x1][y1];
    }

private:
    int h, w;
    std::vector<std::vector<int>> cum;
};


int L=21;
vector<vector<int>>calc(int n){
  vector<vector<int>>dp(L,vector<int>(n,n));
  dp[0][0]=n-1;
  for(int i=0;i<L;i++){
    for(int l=n-2;l>=0;l--){
      dp[i][l]=min(dp[i][l],dp[i][l+1]);
    }
    if(i+1==L)continue;
    for(int l=0;l<n;l++){
      if(dp[i][l]!=n){
        int r=dp[i][l];
        int d=r-l+1;
        if(d==1)continue;
        int nd=(d+1)/2;
        dp[i+1][l]=min(dp[i+1][l],l+nd-1);
        dp[i+1][r-nd+1]=min(dp[i+1][r-nd+1],r);
        if(d%2==1){
          if(l>0){
            dp[i+1][l-1]=min(dp[i+1][l-1],l-1+nd-1);
          }
          if(r-nd+2<n){
            dp[i+1][r-nd+2]=min(dp[i+1][r-nd+2],r+1);
          }
        }
      }
    }
  }
  return dp;
}



int main(){
  ios::sync_with_stdio(false);
  cin.tie(nullptr);

  Log2[0]=0;
  for(int i=1;i<1e6+10;i++){
    Log2[i]=Log2[i/2]+1;
  }

  int H,W;
  cin>>H>>W;
  vector<vector<int>>A(H,vector<int>(W,0));
  rep(x,H){
    string s;
    cin>>s;
    rep(y,W)A[x][y]=s[y]-'0';
  }

  vector<vector<int>>limitH=calc(H);
  vector<vector<int>>limitW=calc(W);

  Cum2D cum(H,W,A);
  int ans=0;
  while(true){
    for(int h=0;h<=min(ans,L-1);h++){
      int w=ans-h;
      if(w<0||w>=L)continue;
      rep(x,H){
        if(limitH[h][x]!=H){
          rep(y,W){
            if(limitW[w][y]!=W){
              int x2=limitH[h][x];
              int y2=limitW[w][y];
              if(cum.query(x,y,x2,y2)==(x2-x+1)*(y2-y+1)){
                print(ans);
                exit(0);
              }
            }
          }
        }
      }
    }
    ans++;
  }
}