#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

const int inf = 1e9;

void solve() {
    int n; cin >> n;
    vector<int> a(n); for(auto& x : a) cin >> x;
    vector<vector<int>> dp(13, vector<int>(n+1, 0)); //dp[cat][i] = best score i can get if i start round cat at card i

    auto score = [&] (int cat, vector<int> cand) {
        assert(cand.size() == 5);
        sort(cand.begin(), cand.end()); //sort candidate vector
        int sum = accumulate(cand.begin(), cand.end(), 0);
        if (cat <= 6) { // 1 - 6
            int ct = 0;
            for (auto x : cand) 
                if (x == cat) ct++;
            return ct * cat;
        }
        if (cat == 7) { // triple
            for (int i = 0; i < 3; ++i) {
                if (cand[i] == cand[i+2]) return sum;
            }
            return 0;
        }
        if (cat == 8) { // quadruple
            for (int i = 0; i < 2; ++i) {
                if (cand[i] == cand[i+3]) return sum;
            }
            return 0;
        }
        if (cat == 9) { // full house
            if (cand[0] == cand[2] && cand[2] != cand[3] && cand[3] == cand[4]) return 25;
            if (cand[0] == cand[1] && cand[1] != cand[2] && cand[2] == cand[4]) return 25;
            return 0;
        }
        if (cat == 10) { // short straight
            for (int i = 0; i < 2; ++i) {
                int tmp = cand[i];
                for (int j = i+1; j < i+5; ++j) {
                    if (j == i+4) return 30;
                    if (cand[j] != tmp + 1) break;
                    tmp++;
                }
            }
            return 0;
        }
        if (cat == 11) { // long straight
            int tmp = cand[0];
            for (int j = 1; j < 6; ++j) {
                if (j == 5) return 40;
                if (cand[j] != tmp+1) break;
                tmp++;
            }
            return 0;
        }
        if (cat == 12) { // chance
            return sum;
        } 
        if (cat == 13) { // yahtzee
            if (cand[0] == cand[4])
                return 50;
            return 0;
        }
        assert(false);
        return 0;
    };

    // iterate cats
    for (int cat = 12; cat >= 0; --cat) {
        // iterate start pos
        for (int i = 0; i < n-4; ++i) {
            // generate candidate hands
            vector<int> cand(5);
            for (int j = 0; j < 5; ++j) cand[j] = a[i+j];
            vector<int> sv = cand, sv2;

            // some flag that doesn't work
            bool ok = 1;
            // iterate bitmask for things to swap out
            for (int j = 0; j < 32; ++j) {
                ok = 1;
                // restore old candidate
                cand = sv;
                // track next replacement dice roll
                int tmp = i+5;
                // fix each dice
                for (int k = 0; k < 5; ++k) {
                    if ((j >> k) & 1) {
                        if (tmp == n) { ok = 0; break; }
                        cand[k] = a[tmp++];
                    }
                }
                if (!ok) continue;

                // save old candidate so we don't stack changes basically
                // then do the same thing but with tmp2 (2nd swap round)
                sv2 = cand;
                for (int k = 0; k < 32; ++k) {
                    ok = 1;
                    cand = sv2;
                    int tmp2 = tmp;
                    for (int l = 0; l < 5; ++l) {
                        if ((k >> l) & 1) {
                            if (tmp2 == n) { ok = 0; break; }
                            cand[l] = a[tmp2++];
                        }
                    }
                    if (!ok) continue;

                    // update dp
                    dp[cat][i] = max(dp[cat][i], score(cat + 1, cand) + (cat == 12 ? 0 : dp[cat+1][tmp2]));
                }
            }
        }
    }

    int ans = -inf;
    for (int i = 0; i < n; ++i) {
        ans = max(ans, dp[0][i]);
    }
    cout << ans << "\n";
}

int main() {
    cin.tie(0);
    cin.sync_with_stdio(0);

	int t = 1;
    // cin >> t;
	while (t--) solve();
}