//#include <iostream>
//#include <vector>
//#include <string>
//#include <algorithm>
//
//using namespace std;
//
//vector<vector<string>> dp; // 记忆化数组
//
//
//string highPrecisionAdd(const string& s1, const string& s2) {
//    int la = s1.length();
//    int lb = s2.length();
//    int lc = max(la, lb);
//    vector<int> a(lc + 1, 0); // +1 to handle carry over
//    vector<int> b(lc + 1, 0);
//    vector<int> c(lc + 1, 0);
//
//    for (int i = 0; i < la; i++) {
//        a[i] = s1[la - i - 1] - '0'; // reverse order
//    }
//    for (int i = 0; i < lb; i++) {
//        b[i] = s2[lb - i - 1] - '0'; // reverse order
//    }
//
//    for (int i = 0; i < lc; i++) {
//        c[i] += a[i] + b[i];
//        if (c[i] >= 10) {
//            c[i + 1] += c[i] / 10;
//            c[i] %= 10;
//        }
//    }
//
//    // handle last carry
//    if (c[lc] > 0) lc++;
//
//    string result;
//    bool leadingZero = true;
//    for (int i = lc - 1; i >= 0; i--) {
//        if (leadingZero && c[i] == 0) continue;
//        leadingZero = false;
//        result.push_back(c[i] + '0');
//    }
//
//    return result.empty() ? "0" : result;
//}
//
//string highPrecisionMultiply(const string& s1, const string& s2) {
//    int la = s1.length();
//    int lb = s2.length();
//    vector<int> a(la, 0);
//    vector<int> b(lb, 0);
//    vector<int> c(la + lb, 0);
//
//    for (int i = 0; i < la; i++) {
//        a[la - i - 1] = s1[i] - '0'; // Reverse order
//    }
//    for (int i = 0; i < lb; i++) {
//        b[lb - i - 1] = s2[i] - '0'; // Reverse order
//    }
//
//    for (int i = 0; i < la; i++) {
//        for (int j = 0; j < lb; j++) {
//            c[i + j] += a[i] * b[j];
//        }
//    }
//
//    // Handle carry
//    for (int i = 0; i < la + lb; i++) {
//        if (c[i] >= 10) {
//            c[i + 1] += c[i] / 10;
//            c[i] %= 10;
//        }
//    }
//
//    // Remove leading zeros
//    int lc = la + lb;
//    while (lc > 1 && c[lc - 1] == 0) lc--;
//
//    string result;
//    for (int i = lc - 1; i >= 0; i--) {
//        result.push_back(c[i] + '0');
//    }
//
//    return result.empty() ? "0" : result;
//}
//
//
//// 计算2的power次方的高精度函数
//string powerOfTwo(int power) {
//    string result = "1";
//    string two = "2";
//    for (int i = 0; i < power; ++i) {
//        result = highPrecisionMultiply(result, two);
//    }
//    return result;
//}
//
//string findMaxRecursive(const vector<string>& b, int left, int right, int power) {
//    if (left > right) {
//        return "0";
//    }
//    if (left == right) {
//        return highPrecisionMultiply(b[left], powerOfTwo(power));
//    }
//    if (dp[left][right] != "-1") {
//        return dp[left][right];
//    }
//
//    string maxHead = highPrecisionAdd(findMaxRecursive(b, left + 1, right, power + 1), highPrecisionMultiply(b[left], powerOfTwo(power)));
//    string maxTail = highPrecisionAdd(findMaxRecursive(b, left, right - 1, power + 1), highPrecisionMultiply(b[right], powerOfTwo(power)));
//    dp[left][right] = (maxHead > maxTail) ? maxHead : maxTail;
//    cout << "" << dp[left][right] << endl;
//    return dp[left][right];
//}
//
//string solve(const vector<vector<string>>& matrix) {
//    string totalMaxScore = "0";
//    for (const auto& row : matrix) {
//        int rowSize = row.size();
//        dp = vector<vector<string>>(rowSize, vector<string>(rowSize, "-1"));
//        totalMaxScore = highPrecisionAdd(totalMaxScore, findMaxRecursive(row, 0, rowSize - 1, 1));
//    }
//    return totalMaxScore;
//}
//
//int main() {
//    int n, m;
//    cin >> n >> m;
//    vector<vector<string>> a(n, vector<string>(m));
//
//    for (int i = 0; i < n; i++) {
//        for (int j = 0; j < m; j++) {
//            cin >> a[i][j];
//        }
//    }
//
//    cout << solve(a) << endl;
//
//    return 0;
//}