#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int n;
int h[20001];

struct NaiveDisjointSet {
    vector<int> parent, counts;
    NaiveDisjointSet(int n) : parent(n, -1), counts(n, 0) {}
    int find(int u) {
        if (u == parent[u]) return u;
        if (u < 0 || u > n - 1 || parent[u] == -1) return -1;
        return parent[u] = find(parent[u]);
    }
    int merge(int u, int v) {
        u = find(u);
        v = find(v);
        if (u == -1) return counts[v];
        if (v == -1) return counts[u];
        if (u == v) return counts[u];
        if (u < v) swap(u, v);
        parent[u] = v;
        return counts[v] += counts[u];
    }
    void add(int u) {
        if (find(u) == -1) {
            parent[u] = u;
            counts[u] = 1;
        }
    }
};

int solve2(vector<pair<int, int> >& order) {
    NaiveDisjointSet sets(n);
    int ret = 0;

    for (int i = 0; i < order.size(); ++i) {
        int idx = order[i].second;
        sets.add(idx);

        int left = sets.find(idx - 1);
        int right = sets.find(idx + 1);
        ret = max(ret, h[idx] * sets.merge(idx, idx - 1));
        ret = max(ret, h[idx] * sets.merge(idx + 1, idx));
    }

    return ret;
}

bool myfunction(const pair<int, int>& a, const pair<int, int>& b) {
    return a.first > b.first;
}

int main()
{
    int numOfCase;
    cin >> numOfCase;

    while(numOfCase) {
        cin >> n;
        for (int i = 0; i < n; ++i) cin >> h[i];

        vector<pair<int, int> > order;
        for (int i = 0; i < n; ++i) order.push_back(make_pair(h[i], i));
        sort(order.begin(), order.end(), myfunction);

        cout << solve2(order) << endl;
        --numOfCase;
    }

    return 0;
}