#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

template <typename T>
struct lazy_segment_tree {
    static const int N = 1e6 + 10;
    const T inf = numeric_limits<T>::max() / 2 - 10;
    const T good_value = 0;
    T a[N], t[4 * N], ch[4 * N];
    T merge(T a, T b) {
        return max(a, b);
    }
    void push(int v, int tl, int tr) {
        if (!ch[v]) {
            return;
        }
        t[v] += ch[v];
        if (tl < tr) {
            ch[v + v] += ch[v];
            ch[v + v + 1] += ch[v];
        }
        ch[v] = 0;
    }
    void update(int l, int r, T x, int v = 1, int tl = 0, int tr = N - 1) {
        push(v, tl, tr);
        if (r < tl || tr < l) return;
        if (l <= tl && tr <= r) {
            ch[v] += x;
            push(v, tl, tr);
            return;
        }
        int tm = (tl + tr) / 2;
        update(l, r, x, v + v, tl, tm);
        update(l, r, x, v + v + 1, tm + 1, tr);

    }
    T get(int l, int r, int v = 1, int tl = 0, int tr = N - 1) {
        push(v, tl, tr);
        if (r < tl || tr < l) return good_value;
        if (l <= tl && tr <= r) return t[v];
        int tm = (tl + tr) / 2;
        T res = merge(get(l, r, v + v, tl, tm), get(l, r, v + v + 1, tm + 1, tr));
        t[v] = merge(t[v + v], t[v + v + 1]);
        return res;
    }
};

lazy_segment_tree<int> tree;

const int N = 1e6 + 10;
int a[N];
int l[N], r[N];
bool alive[N];
vector<int> open[N], close[N];
int id_lef[N], id_rig[N];

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
#ifdef LOCAL
    freopen("input.txt", "r", stdin);
#endif

    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    int q;
    cin >> q;
    for (int i = 1; i <= q; i++) {
        cin >> l[i] >> r[i];
    }

    for (int i = 1; i <= q; i++) {
        open[l[i]].push_back(i);
        close[r[i]].push_back(i);
        alive[i] = true;
    }

    multiset<int> right_ends;
    for (int i = 1; i <= n; i++) {
        sort(open[i].begin(), open[i].end(), [&](int x, int y) {
            return r[x] > r[y];
        });

        for (int j : open[i]) {
            if (!right_ends.empty() && *right_ends.rbegin() >= r[j]) {
                alive[j] = false;
            }
            right_ends.insert(r[j]);
        }

        for (int j : close[i]) {
            right_ends.erase(right_ends.find(r[j]));
        }
    }

    vector<pair<int, int>> segs;
    for (int i = 1; i <= q; i++) {
        if (alive[i]) {
            segs.emplace_back(l[i], r[i]);
        }
    }
    sort(segs.begin(), segs.end());
    for (int i = 0; i + 1 < segs.size(); i++) {
        assert(segs[i].first < segs[i + 1].first && segs[i].second < segs[i + 1].second);
    }

    for (int i = 1; i <= n; i++) {
        open[i].clear();
        close[i].clear();
        id_lef[i] = -1;
        id_rig[i] = -1;
    }

    for (int i = 0; i < segs.size(); i++) {
        auto [l, r] = segs[i];
        open[l].push_back(i);
        close[r].push_back(i);
    }
    set<int> ids;
    for (int i = 1; i <= n; i++) {
        for (int j : open[i]) {
            ids.insert(j);
        }
        if (!ids.empty()) {
            id_lef[i] = *ids.begin();
            id_rig[i] = *ids.rbegin();
        }
        for (int j : close[i]) {
            ids.erase(j);
        }
    }

    vector<int> ord(n);
    iota(ord.begin(), ord.end(), 1);
    sort(ord.begin(), ord.end(), [&](int i, int j) {
        return a[i] > a[j];
    });
    ll ans = 0;
    for (int i : ord) {
        if (id_lef[i] != -1) {
            ans = max(ans, 1ll * a[i] * tree.get(id_lef[i], id_rig[i]));
            tree.update(id_lef[i], id_rig[i], 1);
        }
    }
    cout << ans << "\n";

#ifdef LOCAL
    cout << "\nTime elapsed: " << double(clock()) / CLOCKS_PER_SEC << " s.\n";
#endif
}