#include <iostream>
#include <iomanip>//小数点出力用
//cout << fixed << setprecision(10) << ans;
#include <cmath>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
using ll = long long;
using namespace std;
#define modPHash (ll)((1LL<<61)-1)
#define modP (ll)998244353
bool chkrng0idx(int pos, int sup) { return (0 <= pos && pos < sup); }
int clk4(int num) { return (num - 2) * (num % 2); }
void yn(bool tf) { cout << (tf ? "Yes\n" : "No\n"); }

#define segL (1 << 20)
#define lazyValueEmpty -4611686018427387904
ll segT[segL * 2];
ll lazySeg[segL * 2];

int c2(int X) {
    int res = 0;
    int t = X;
    if (t == 0)t = segL;
    while (1) {
        if (t % 2 == 0) {
            t /= 2;
            res++;
        }
        else {
            break;
        }
    }
    return res;
}

void lazydiv(const int L, const int R, int id, int interL, int interR) {
    if (lazySeg[id] != lazyValueEmpty) {
        if (!(L <= interL && interR <= R)) {
            if (lazySeg[2 * id] == lazyValueEmpty)lazySeg[2 * id] = lazySeg[id];
            else lazySeg[2 * id] += lazySeg[id];
            if (lazySeg[2 * id + 1] == lazyValueEmpty)lazySeg[2 * id + 1] = lazySeg[id];
            else lazySeg[2 * id + 1] += lazySeg[id];
            segT[2 * id] += lazySeg[id];
            segT[2 * id + 1] += lazySeg[id];
            lazySeg[id] = lazyValueEmpty;
        }

    }
    if (!(L <= interL && interR <= R)) {
        if (interR - interL > 1) {
            if (L < (interL + interR) / 2) {
                lazydiv(L, R, 2 * id, interL, (interL + interR) / 2);
            }
            if ((interL + interR) / 2 < R) {
                lazydiv(L, R, 2 * id + 1, (interL + interR) / 2, interR);
            }
        }
    }
}

void upperupdate(const int L, const int R, int id, int interL, int interR) {
    if (!(L <= interL && interR <= R)) {
        if (interR - interL > 1) {
            if (L < (interL + interR) / 2) {
                upperupdate(L, R, 2 * id, interL, (interL + interR) / 2);
            }
            if ((interL + interR) / 2 < R) {
                upperupdate(L, R, 2 * id + 1, (interL + interR) / 2, interR);
            }
        }
        segT[id] = max(segT[2 * id], segT[2 * id + 1]);
    }
}

void addR(int L, int R, ll X) {
    lazydiv(L, R, 1, 0, segL);
    int tL = L;
    while (tL != R) {
        int b = c2(tL);
        for (;b >= 0;b--) {
            if (tL + (1 << b) <= R) {
                int segIdx = (tL + segL) >> b;
                if (lazySeg[segIdx] == lazyValueEmpty)lazySeg[segIdx] = X;
                else lazySeg[segIdx] += X;
                segT[segIdx] += X;
                tL += (1 << b);
                break;
            }
        }
    }
    upperupdate(L, R, 1, 0, segL);
}

ll getM(int L, int R) {
    lazydiv(L, R, 1, 0, segL);
    ll res = -1e18;
    int tL = L;
    while (tL != R) {
        int b = c2(tL);
        for (;b >= 0;b--) {
            if (tL + (1 << b) <= R) {
                int segIdx = (tL + segL) >> b;
                res = max(res, segT[segIdx]);
                tL += (1 << b);
                break;
            }
        }
    }
    return res;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    ll best = -1e18;
    int N;
    cin >> N;
    vector<int>A(N);
    for (int i = 0;i < N;i++)cin >> A[i];
    for (int f = 0;f <= 1;f++) {
        for (int i = 0;i < segL * 2;i++) {
            segT[i] = 0;
            lazySeg[i] = lazyValueEmpty;
        }
        ll thisMax = -1e9;
        ll tmp = 0;
        for (int i = 0;i < N;i++) {//初期化
            tmp += A[i];
            addR(i, i + 1, tmp);
        }
        for (int i = 0;i < N - 1;i++) {
            if(i != 0)addR(0, i, A[i]);
            addR(i + 1, segL, -A[i]);
            thisMax = max(thisMax, getM(0, i + 1));
            best = max(best, thisMax * getM(i + 1, N));
        }
        for (int i = 0;i < N;i++) {
            A[i] *= -1;
        }
    }
    cout << best;

    return 0;
}