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

vector<int> riceBalls;
vector<int> prefixSum;
vector<vector<int>> memo;

// Helper function to calculate sum of rice balls from index i to j
int getSum(int i, int j) {
    return prefixSum[j + 1] - prefixSum[i];
}

// Recursive function to find the maximum rice ball size that can be formed from subarray [i, j]
int maxRiceBall(int i, int j) {
    if (i == j) return riceBalls[i]; // Single rice ball case
    if (memo[i][j] != -1) return memo[i][j]; // Return memoized result if available

    int maxBall = 0;

    // Try merging adjacent sections
    for (int mid = i; mid < j; ++mid) {
        if (maxRiceBall(i, mid) == maxRiceBall(mid + 1, j)) {
            maxBall = max(maxBall, maxRiceBall(i, mid) + maxRiceBall(mid + 1, j));
        }
    }

    // Try merging with one rice ball in between
    for (int mid = i; mid < j - 1; ++mid) {
        int leftSum = getSum(i, mid);
        int rightSum = getSum(mid + 2, j);

        if (leftSum == rightSum) {
            int leftMax = maxRiceBall(i, mid);
            int rightMax = maxRiceBall(mid + 2, j);
            if (leftMax > 0 && rightMax > 0) {
                maxBall = max(maxBall, leftSum + riceBalls[mid + 1] + rightSum);
            }
        }
    }

    // Store and return the maximum size for the subarray [i, j]
    memo[i][j] = max(maxBall, getSum(i, j)); // Consider the option of not merging at all
    return memo[i][j];
}

int main() {
    int N;
    cin >> N;
    riceBalls.resize(N);
    prefixSum.resize(N + 1, 0);
    memo.assign(N, vector<int>(N, -1));

    for (int i = 0; i < N; ++i) {
        cin >> riceBalls[i];
        prefixSum[i + 1] = prefixSum[i] + riceBalls[i];
    }

    // Calculate the largest rice ball possible
    int maxRiceBallSize = 0;
    for (int i = 0; i < N; ++i) {
        for (int j = i; j < N; ++j) {
            maxRiceBallSize = max(maxRiceBallSize, maxRiceBall(i, j));
        }
    }

    cout << maxRiceBallSize << endl;
    return 0;
}