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

typedef long long ll;
const int MAXN = 1e6 + 10;
const int p = 998244353, g = 3, gi = 332748118;
ll qpow(ll a, ll b)
{
    ll res = 1;
    while (b)
    {
        if (b & 1)
            res = res * a % p;
        a = a * a % p;
        b >>= 1;
    }
    return res;
}
vector<int> R(MAXN);

void NTT(vector<ll> &A, int n, int op)
{
    // op:是否逆

    // 利用二进制的一半是其二进制右移一位的性质
    // 反转后其二进制是其一半反转后右移一位。 最左边的位数为其最右边的位数反转
    for (int i = 0; i < n; i++)
        R[i] = R[i / 2] / 2 + ((i & 1) ? n / 2 : 0);

    // 只有比其小再交换，防止交换两次回到原来的位置
    for (int i = 0; i < n; i++)
        if (i < R[i])
            swap(A[i], A[R[i]]);

    // 合并区间长度的一半
    for (int i = 2; i <= n; i <<= 1)
    {
        ll g1 = qpow(op == 1 ? g : gi, (p - 1) / i);
        // 合并区间在整个区间的哪个位置
        for (int j = 0; j < n; j += i)
        {
            ll gk = 1;
            // 在合并区间的位置
            for (int k = j; k < j + i / 2; k++, gk = gk * g1 % p)
            {
                ll x = A[k], y = gk * A[k + i / 2] % p;
                A[k] = (x + y) % p;
                A[k + i / 2] = (p + x - y) % p;
            }
        }
    }
}

template <typename T>
struct ST
{
    T MAX = 1e9;
    vector<vector<T>> maxn;
    vector<T> a;
    const int m = 20;
    vector<T> LOG;

    ST() {}
    ST(int n, vector<T> b)
    {
        a.resize(n + 1, 0);
        a = b;
        init(n);
    }

    void init(int n)
    {
        if (std::is_same<T, ll>::value)
            MAX = 1e18;
        maxn.resize(n + 1, vector<T>(m + 1, -MAX));
        LOG.resize(n + 1, 0);
        for (int i = 1; i <= n; i++)
            maxn[i][0] = a[i];
        LOG[1] = 0;
        for (int i = 2; i <= n; i++)
            LOG[i] = LOG[i / 2] + 1;
        for (int j = 1; (1 << j) <= n; j++)
            for (int i = 1; i + (1 << (j - 1)) <= n; i++)
                maxn[i][j] = max(maxn[i][j - 1], maxn[i + (1 << (j - 1))][j - 1]);
    }

    T query_max(int l, int r)
    {
        int d = LOG[r - l + 1];
        return max(maxn[l][d], maxn[r - (1 << d) + 1][d]);
    }
};

void solve()
{
    int n;
    cin >> n;
    vector<int> a(n + 1);
    vector<int> s;
    for (int i = 1; i <= n; ++i)
    {
        cin >> a[i];
        s.push_back(a[i]);
    }
    sort(s.begin(), s.end());
    int cnt = s.erase(unique(s.begin(), s.end()), s.end()) - s.begin();
    map<int, int> rk;
    for (int i = 0; i < cnt; ++i)
        rk[s[i]] = i + 1;
    for (int i = 1; i <= n; ++i)
        a[i] = rk[a[i]];

    vector<ll> ans(n + 1);
    ST<int> st(n, a);
    vector<vector<array<int, 3>>> seg(n + 1);
    for (int i = 1; i <= n; ++i)
    {
        int lf = i, rf = i;
        int l = 1, r = i - 1, pos = -1;
        while (l <= r)
        {
            int mid = l + r >> 1;
            if (st.query_max(mid, i - 1) < a[i])
                r = mid - 1, pos = mid;
            else
                l = mid + 1;
        }
        if (pos != -1)
            lf = pos;

        l = i + 1, r = n, pos = -1;
        while (l <= r)
        {
            int mid = l + r >> 1;
            if (st.query_max(i + 1, mid) < a[i])
                l = mid + 1, pos = mid;
            else
                r = mid - 1;
        }
        if (pos != -1)
            rf = pos;
        seg[a[i]].push_back({lf, rf, i});
    }

    for (int i = 1; i <= n; ++i)
    {
        if (seg[i].empty())
            continue;
        vector<ll> g;
        int lstr = -1, rf = 0;
        for (auto [l, r, pos] : seg[i])
        {
            if (lstr == -1)
                lstr = pos, rf = r, g.push_back(pos - l + 1);
            else
            {
                if (pos == rf + 1)
                {
                    g.push_back(pos - lstr);
                    lstr = pos, rf = r;
                }
                else
                {
                    g.push_back(rf - lstr + 1);
                    // FFT
                    int m = g.size();
                    int k = 1;
                    while (k < m * 2)
                        k <<= 1;
                    vector<ll> lenf(k + 1), leng(k + 1);
                    for (int i = 0; i < m; ++i)
                        lenf[i] = g[i], leng[m - i - 1] = g[i];
                    NTT(lenf, k, 1);
                    NTT(leng, k, 1);
                    for (int i = 0; i <= k; ++i)
                        lenf[i] = lenf[i] * leng[i] % p;
                    NTT(lenf, k, -1);
                    int inv = qpow(k, p - 2);
                    for (int i = 0; i <= k; ++i)
                        lenf[i] = lenf[i] * inv % p;
                    for (int i = 1; i < m; ++i)
                        ans[i] = (ans[i] + lenf[m - i - 1]) % p;

                    lstr = pos, rf = r;
                    g.clear();
                    g.push_back(pos - l + 1);
                }
            }
        }

        g.push_back(rf - lstr + 1);
        int m = g.size();
        int k = 1;
        while (k < m * 2)
            k <<= 1;
        vector<ll> lenf(k + 1), leng(k + 1);
        for (int i = 0; i < m; ++i)
            lenf[i] = g[i], leng[m - i - 1] = g[i];
        NTT(lenf, k, 1);
        NTT(leng, k, 1);
        for (int i = 0; i <= k; ++i)
            lenf[i] = lenf[i] * leng[i] % p;
        NTT(lenf, k, -1);
        int inv = qpow(k, p - 2);
        for (int i = 0; i <= k; ++i)
            lenf[i] = lenf[i] * inv % p;
        for (int i = 1; i < m; ++i)
            ans[i] = (ans[i] + lenf[m - i - 1]) % p;
        g.clear();
    }

    // for (int i = 1; i <= n; ++i)
    //     cerr << i << " " << ans[i] << '\n';

    ll res = 0;
    for (int i = 1; i <= n; ++i)
        res = (res + 1ll * i * ans[i] % p * ans[i] % p) % p;
    cout << res << '\n';
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);

    int t = 1;
    cin >> t;
    while (t--)
    {
        solve();
    }
    return 0;
}