#include <bits/stdc++.h>
#define int int64_t

using namespace std;

const int N = 2e5;
int n;
int h[N];
int tree[400004];  //дерево отрезков. в вершинах хранятся минимумы

void build_tree(int v, int tl, int tr) {
    if (tl == tr) {
        tree[v] = h[tl];
    } else {
        int tm = (tl + tr) / 2;
        build_tree(v * 2, tl, tm);
        build_tree(v * 2 + 1, tm + 1, tr);
        tree[v] = min(tree[v * 2], tree[v * 2 + 1]);    //сохраняем минимум вместо суммы
    }
}

//Запрос минимума
int get_min(int l, int r, int v, int tl, int tr) {
    //вариант 1
    if (l <= tl && tr <= r) {
        return tree[v];
    }

    //вариант 2
    if (tr < l || r < tl) {
        return INT_MAX;     //Значение, которое не повлияет на общий минимум
    }

    //вариант 3
    int tm = (tl + tr) / 2;
    return min(get_min(l, r, v * 2,     tl,     tm),    //минимум вместо суммы.
               get_min(l, r, v * 2 + 1, tm + 1, tr));
}

int f(int idx){
    int r_l = 0, r_r = n - 1;
    int l = 0, r = idx - 1;
    if(l < r && get_min(l, r, 1, 0, n - 1) < h[idx]){
        while(l < r){
            int m = (l + r) / 2;
            if(get_min(m + 1, r, 1, 0, n - 1) < h[idx])
                l = m + 1;
            else
                r = m;
        }
        r_l = l;
    }
    l = idx + 1, r = n - 1;
    if(l < r && get_min(l, r, 1, 0, n - 1) < h[idx]){
        while(l < r){
            int m = (l + r) / 2;
            if(get_min(l, m, 1, 0, n - 1) < h[idx])
                r = m;
            else
                l = m + 1;
        }
        r_r = l;
    }
    if(h[r_r] < h[idx])
        r_r--;
    if(h[r_l] < h[idx])
        r_l++;
    return r_r - r_l + 1;
}

int32_t main() {
    cin >> n;
    for (int i = 0; i < n; ++i)
        cin >> h[i];
    build_tree(1, 0, n - 1);
    int mn_w = LLONG_MAX, mn_h = LLONG_MAX;
    for(int i = 0; i < n; i++){
        if(h[i] == 0)
            continue;
        int cur_h = h[i];
        int cur_w = f(i);
        if(cur_h > cur_w)
            swap(cur_h, cur_w);
        mn_h = min(mn_h, cur_h);
        mn_w = min(mn_w, cur_w);
    }
    cout << mn_h * mn_w;
}