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

const int P = 998244353;
using Poly = vector<int>;
#define MUL(a, b) (i64(a) * (b) % P)
#define ADD(a, b) (((a) += (b)) >= P ? (a) -= P : 0)
#define SUB(a, b) (((a) -= (b)) < 0 ? (a) += P : 0)
Poly getInv(int L)
{
    Poly inv(L);
    inv[1] = 1;
    for (int i = 2; i < L; i++)
        inv[i] = MUL((P - P / i), inv[P % i]);
    return inv;
}
int POW(i64 a, int b = P - 2, i64 x = 1)
{
    for (; b; b >>= 1, a = a * a % P)
        if (b & 1)
            x = x * a % P;
    return x;
}
namespace NTT
{
    const int g = 3;
    Poly Omega(int L)
    {
        int wn = POW(g, P / L);
        Poly w(L);
        w[L >> 1] = 1;
        for (int i = L / 2 + 1; i < L; i++)
            w[i] = MUL(w[i - 1], wn);
        for (int i = L / 2 - 1; i >= 1; i--)
            w[i] = w[i << 1];
        return w;
    }
    auto W = Omega(1 << 20);
    void DIF(int *a, int n)
    {
        for (int k = n >> 1; k; k >>= 1)
            for (int i = 0, y; i < n; i += k << 1)
                for (int j = 0; j < k; j++)
                    y = a[i + j + k], a[i + j + k] = MUL(a[i + j] - y + P, W[k + j]), ADD(a[i + j], y);
    }
    void IDFT(int *a, int n)
    {
        for (int k = 1; k < n; k <<= 1)
            for (int i = 0, x, y; i < n; i += k << 1)
                for (int j = 0; j < k; j++)
                    x = a[i + j], y = MUL(a[i + j + k], W[k + j]),
                    a[i + j + k] = x - y < 0 ? x - y + P : x - y, ADD(a[i + j], y);
        int Inv = P - (P - 1) / n;
        for (int i = 0; i < n; i++)
            a[i] = MUL(a[i], Inv);
        reverse(a + 1, a + n);
    }
}
namespace Polynomial
{
    int norm(int n) { return 1 << (__lg(n - 1) + 1); }
    void norm(Poly &a)
    {
        if (!a.empty())
            a.resize(norm(a.size()), 0);
        else
            a = {0};
    }
    void DFT(Poly &a) { NTT::DIF(a.data(), a.size()); }
    void IDFT(Poly &a) { NTT::IDFT(a.data(), a.size()); }
    Poly &dot(Poly &a, Poly &b)
    {
        for (int i = 0; i < a.size(); i++)
            a[i] = MUL(a[i], b[i]);
        return a;
    }
    Poly operator*(Poly a, Poly b)
    {
        int n = a.size() + b.size() - 1, L = norm(n);
        if (a.size() <= 8 || b.size() <= 8)
        {
            Poly c(n);
            for (int i = 0; i < a.size(); i++)
                for (int j = 0; j < b.size(); j++)
                    c[i + j] = (c[i + j] + (i64)a[i] * b[j] % P);
            return c;
        }
        a.resize(L), b.resize(L);
        DFT(a), DFT(b), dot(a, b), IDFT(a);
        return a.resize(n), a;
    }
}
using namespace Polynomial;

void solve()
{
    int n;
    cin >> n;
    vector<int> a(n + 1);
    for (int i = 1; i <= n; i++)
        cin >> a[i];
    vector<array<int, 19>> b(n + 1);
    map<int, vector<int>> pos;
    vector<int> logn(n + 1, -1);
    for (int i = 1; i <= n; i++)
    {
        logn[i] = logn[i >> 1] + 1;
        pos[a[i]].push_back(i);
        b[i][0] = a[i];
    }
    for (int j = 1; j <= 18; j++)
        for (int i = 1; i + (1 << j) - 1 <= n; i++)
            b[i][j] = max(b[i][j - 1], b[i + (1 << (j - 1))][j - 1]);
    auto ask = [&](int l, int r) -> int
    {
        int s = logn[r - l + 1];
        return max(b[l][s], b[r - (1 << s) + 1][s]);
    };

    Poly ans(n + 1);
    auto solve = [&](auto &solve, int cur, int l, int r) -> void
    {
        if (l < cur)
        {
            int val = ask(l, cur - 1);
            auto &t = pos[val];
            vector<int> tmp{l - 1};
            for (auto it = lower_bound(t.begin(), t.end(), l); it != t.end() and *it < cur; it++)
                tmp.push_back(*it);
            tmp.push_back(cur);

            Poly f(tmp.size() - 1);
            for (int j = 1; j < tmp.size(); j++)
                f[j - 1] = tmp[j] - tmp[j - 1];
            auto g = f;
            reverse(g.begin(), g.end());
            auto h = f * g;
            int p = f.size();
            for (int j = p - 1; j < p * 2 - 1; j++)
                ADD(ans[j - p + 1], h[j]);

            for (int j = 1; j + 1 < tmp.size(); j++)
            {
                if (j == 1)
                    solve(solve, tmp[j], tmp[j - 1] + 1, tmp[j + 1] - 1);
                else
                    solve(solve, tmp[j], tmp[j], tmp[j + 1] - 1);
            }
        }
        if (cur < r)
        {
            int val = ask(cur + 1, r);
            auto &t = pos[val];
            vector<int> tmp{cur};
            for (auto it = lower_bound(t.begin(), t.end(), cur); it != t.end() and *it <= r; it++)
                tmp.push_back(*it);
            tmp.push_back(r + 1);

            Poly f(tmp.size() - 1);
            for (int j = 1; j < tmp.size(); j++)
                f[j - 1] = tmp[j] - tmp[j - 1];
            auto g = f;
            reverse(g.begin(), g.end());
            auto h = f * g;
            int p = f.size();
            for (int j = p - 1; j < p * 2 - 1; j++)
                ADD(ans[j - p + 1], h[j]);

            for (int j = 1; j + 1 < tmp.size(); j++)
            {
                if (j == 1)
                    solve(solve, tmp[j], tmp[j - 1] + 1, tmp[j + 1] - 1);
                else
                    solve(solve, tmp[j], tmp[j], tmp[j + 1] - 1);
            }
        }
    };

    solve(solve, 0, 1, n);
    int res = 0;
    for (int i = 1; i <= n; i++)
        res = (res + 1ll * i * ans[i] % P * ans[i] % P) % P;
    cout << res << '\n';
}
/*
 3
 11
 1 1 2 1 2 2 3 3 2 3 1
 3
 2024 5 26
 3
 1000000000 1000000000 1000000000
*/

signed main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);

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