#include <bits/stdc++.h>
#define mxQ 504
#define mod 998244353
using namespace std;
typedef long long ll;

int T, n, Q, A;
struct Pnt {
    int l, r, m;
    bool operator< (const Pnt &x) const
    {
        if (m<x.m) { return true; }
        if (m>x.m) { return false; }
        if (l<x.l) { return true; }
        if (l>x.l) { return false; }
        return r>x.r;
    }
} p[mxQ], q1[mxQ], q2[mxQ];

int num_mx[mxQ], tot_mx, vec[mxQ*2], dp[mxQ*2], tg[mxQ*2], sum[mxQ*2];

ll pw (ll bs, ll t)
{
    ll res=1;
    while (t) {
        if (t&1) { res=res*bs%mod; }
        bs=bs*bs%mod; t>>=1;
    }
    return res;
}

int main ()
{
    // freopen("0test.in", "r", stdin);
    // freopen("0test.out", "w", stdout);

    scanf("%d", &T);
    while (T--) {
        scanf("%d %d %d", &n, &Q, &A);
        for (int i=1; i<=Q; i++) {
            scanf("%d %d %d", &p[i].l, &p[i].r, &p[i].m);
            num_mx[i]=p[i].m;
        }

        sort(num_mx+1, num_mx+Q+1);
        tot_mx=unique(num_mx+1, num_mx+Q+1)-(num_mx+1);

        sort(p+1, p+Q+1);

        int pos=1; ll ans=1;

        for (int t=1; t<=tot_mx; t++) {
            int tot1=0, tot2=0, totv=0;
            while (pos<=Q && p[pos].m==num_mx[t]) { q1[++tot1]=p[pos]; pos++; }

            int mnr=n+1;
            for (int i=tot1; i>=1; i--) {
                if (q1[i].r<mnr) { q2[++tot2]=q1[i]; mnr=q1[i].r; }
            }
            for (int i=1; i<=(tot2/2); i++) { swap(q2[i], q2[tot2-i+1]); }

            ll frac=(num_mx[t]-1)*pw(num_mx[t], mod-2) %mod;
            dp[0]=1;
            for (int i=1; i<=tot2; i++) {
                dp[i]=0;
                for (int j=0; j<i; j++) {
                    dp[i] += (-1)*dp[j]*pw(frac, q2[i].r-max(q2[j].r, q2[i].l-1)) %mod;
                    dp[i]%=mod;
                }
            }

            /*---------------------------------------*/

            for (int i=1; i<=tot1; i++) {
                vec[++totv]=q1[i].l;
                vec[++totv]=q1[i].r+1;
            }
            vec[++totv]=n+1;

            sort(vec+1, vec+totv+1);
            totv=unique(vec+1, vec+totv+1)-(vec+1);

            fill(tg, tg+totv+1, 0);
            for (int i=1; i<=tot1; i++) {
                int idl=lower_bound(vec+1, vec+totv+1, q1[i].l)-vec;
                tg[idl]++;
                int idr=lower_bound(vec+1, vec+totv+1, q1[i].r+1)-vec;
                tg[idr]--;
            }
            for (int i=1; i<=totv; i++) { tg[i]+=tg[i-1]; }

            fill(sum, sum+totv+1, 0);
            for (int i=1; i<=totv; i++) {
                sum[i]=sum[i-1]+(tg[i-1]!=0)*(vec[i]-vec[i-1]);
            }

            for (int i=pos; i<=Q; i++) {
                int id=upper_bound(vec+1, vec+totv+1, p[i].l)-vec;

                p[i].l=p[i].l-(sum[id]-(tg[id-1]!=0)*(vec[id]-1-p[i].l))+(tg[id-1]!=0);
                id=upper_bound(vec+1, vec+totv+1, p[i].r)-vec;
                p[i].r=p[i].r-(sum[id]-(tg[id-1]!=0)*(vec[id]-1-p[i].r));

                if (p[i].l>p[i].r) { ans=0; break; }
            }
            if (!ans) { break; }

            n-=sum[totv];

            /*---------------------------------------*/

            ll res=0;
            for (int i=0; i<=tot2; i++) { res+=dp[i]; res%=mod; }
            res*=pw(num_mx[t], sum[totv]); res%=mod;
            ans*=res; ans%=mod;
        }

        ans*=pw(A, n); ans%=mod;
        ans=(ans+mod)%mod;

        printf("%lld\n", ans);
    }

    return 0;
}