#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <fstream>
#include <cassert>
#include <cstring>
#include <unordered_set>
#include <unordered_map>
#include <numeric>
#include <ctime>
#include <bitset>
#include <complex>

using namespace std;

struct Solver {
    int n, m;
    vector<vector<int>> a;
    vector<vector<vector<int>>> dp;
    vector<vector<vector<pair<int, int>>>> wr;

    bool can_afford(int i, int l, int r) {
        for (int j = l; j <= r; j++) {
            if (a[i][j] == 0) {
                return false;
            }
        }
        return true;
    }

    void calc() {
        dp.resize(n, vector<vector<int>> (m, vector<int> (m)));
        wr.resize(n, vector<vector<pair<int, int>>> (m, vector<pair<int, int>> (m, {-1, -1})));
        for (int i = 0; i < n; i++) {
            for (int l = 0; l < m; l++) {
                for (int r = l; r < m; r++) {
                    if (!can_afford(i, l, r)) {
                        continue;
                    }
                    if (i == 0) {
                        dp[i][l][r] = r - l + 1;
                        continue;
                    }
                    for (int sl = l; sl <= r; sl++) {
                        for (int sr = sl; sr <= r; sr++) {
                            dp[i][l][r] = max(dp[i][l][r], dp[i - 1][sl][sr]);
                        }
                    }
                    dp[i][l][r] += (r - l + 1);
                }
            }
        }
    }

    void init(vector<vector<int>> &a_) {
        a = a_;
        n = (int)a.size();
        m = (int)a[0].size();
        dp.clear();
        calc();
    }
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);

    int n, m;
    cin >> n >> m;
    int st = 0;
    vector<vector<int>> a(n, vector<int> (m));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            char c;
            cin >> c;
            a[i][j] = (c == '1');
            st += a[i][j];
        }
    }
    Solver::init(a);
    auto up = Solver::dp;
    reverse(a.begin(), a.end());
    Solver::init(a);
    auto dw = Solver::dp;
    reverse(dw.begin(), dw.end());
    int ans = 0;
    for (int i = 0; i < n; i++) {
        for (int l = 0; l < m; l++) {
            for (int r = l; r < m; r++) {
                ans = max(ans, up[i][l][r] + dw[i][l][r] - (r - l + 1));
            }
        }
    }
    cout << ans << endl;
}