// 18.12 Given an n x n matrix, find the submatrix with largest sum. Return the sum as the result.

 #include <algorithm>

 #include <climits>

 #include <iostream>

 #include <vector>

 using namespace std;

 class Solution {

 public:

     int largestSubmatrixSum (const vector<vector<int> > &matrix) {

         n = matrix.size();

         if (n == ) {

             return ;

         }

         m = matrix[].size();

         if (m == ) {

             return ;

         }

         int i, j, k;

         vector<int> v;

         int msum;

         int sum;

         v.resize(m);

         msum = INT_MIN;

         for (i = ; i < n; ++i) {

             fill(v.begin(), v.end(), );

             for (j = i; j < n; ++j) {

                 for (k = ; k < m; ++k) {

                     v[k] += matrix[j][k];

                 }

                 sum = maxSubarraySum(v, m);

                 msum = max(msum, sum);

             }

         }

         v.clear();

         return msum;

     };

 private:

     int n, m;

     int maxSubarraySum(const vector<int> &v, int n) {

         int msum;

         int sum;

         int i;

         msum = INT_MIN;

         for (i = ; i < n; ++i) {

             if (v[i] >= ) {

                 msum = max(msum, v[i]);

                 break;

             }

         }

         if (i == n) {

             return msum;

         }

         msum = sum = ;

         for (i = ; i < n; ++i) {

             sum += v[i];

             msum = max(msum, sum);

             sum = max(sum, );

         }

         return msum;

     };

 };

 int main()

 {

     int i, j;

     int n, m;

     vector<vector<int> > matrix;

     Solution sol;

     while (cin >> n >> m && (n >  && m > )) {

         matrix.resize(n);

         for (i = ; i < n; ++i) {

             matrix[i].resize(m);

             for (j = ; j < m; ++j) {

                 cin >> matrix[i][j];

             }

         }

         cout << sol.largestSubmatrixSum(matrix) << endl;

         for (i = ; i < n; ++i) {

             matrix[i].clear();

         }

         matrix.clear();

     }

     return ;

 }