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

// 高精度类
// 60位为一个元素存储
class big_int
{
public:
    #define size 5
    unsigned long long data[size] = {};
    // 修复为60位一元素状态
    void fix()
    {
        for(int i = 0; i < size - 1; i++)
            if(data[i] >> 60 == 1)
                data[i + 1]++, data[i] -= (unsigned long long)1 << 60;
    }
    big_int() {}
    // val * 2 ^ pos
    big_int(int pos, int val)
    {
        data[(pos - 1) / 60] = (unsigned long long)val << pos % 61;
        fix();
    }
    big_int operator+(big_int val)
    {
        big_int temp = *this;
        for(int i = 0; i < size; i++)
            temp.data[i] += val.data[i];
        temp.fix();
        return temp;
    }
    bool operator<(big_int val)
    {
        for(int i = size - 1; i >= 0; i--)
        {
            if(data[i] < val.data[i])
                return true;
            if(data[i] > val.data[i])
                return false;
        }
        return false;
    }
    friend ostream &operator<<(ostream &output, const big_int &obj)
    {
        int i = size - 1;
        while(i && !obj.data[i--]);
        output << obj.data[i];
        for(--i; i >= 0; i--)
        {
            unsigned long long temp = obj.data[i];
            int zero = 60;
            while(temp)
                temp /= 10, zero--;
            while(zero--)
                output << 0;
            output << obj.data[i];
        }
        return output;
    }
} ans;

inline big_int max(big_int a, big_int b)
{
    return a < b ? b : a;
}

int n, m;
int main()
{
    cin >> n >> m;
    vector<int> nums(m);
    for(int i = 0; i < n; i++)
    {
        // 单个行最大得分
        big_int get;
        // dp[i][j] 代表剩下i~j元素最大行得分
        vector<vector<big_int>> dp(m, vector<big_int>(m));
        for(int j = 0; j < m; j++)
            cin >> nums[j];
        // 处理边缘A
        for(int j = m - 2; j >= 0; j--)
            dp[0][j] = dp[0][j + 1] + big_int(m - 1 - j, nums[j + 1]);
        // 处理边缘B
        for(int j = 1; j < m; j++)
            dp[j][m - 1] = dp[j - 1][m - 1] + big_int(j, nums[j - 1]);
        // 动态转移方程
        // dp[j][k] = max(dp[j - 1][k] + 取走nums[j - 1]得分, dp[j][k + 1] + 取走nums[k + 1]得分)
        for(int j = 1; j < m - 1; j++)
            for(int k = m - 2; k >= j; k--)
                dp[j][k] = max(dp[j - 1][k] + big_int(m - (k - j + 1), nums[j - 1]), dp[j][k + 1] + big_int(m - (k - j + 1), nums[k + 1]));
        // 获得最大的分 dp[j][j] + 取走nums[j]得分
        for(int j = 0; j < m; j++)
            get = max(get, dp[j][j] + big_int(m, nums[j]));
        ans = ans + get;
    }
    cout << ans;
    return 0;
}