#include <bits/stdc++.h>

#define all(x) (x).begin(), (x).end()
#define fr first
#define sc second
#define unique(a) a.resize(unique(a.begin(), a.end()) - a.begin())
#define shuffle(a) shuffle(a.begin(), a.end(), rnd)

using namespace std;

using ll = long long;

#ifdef ONPC
mt19937 rnd(224);
mt19937_64 rndll(231);
#else
mt19937 rnd(chrono::high_resolution_clock::now().time_since_epoch().count());
mt19937_64 rndll(chrono::high_resolution_clock::now().time_since_epoch().count());
#endif


template<typename T>
void setmin(T &x, T y) {
    x = min(x, y);
}

template<typename T>
void setmax(T &x, T y) {
    x = max(x, y);
}

#define TIME (clock() * 1.0 / CLOCKS_PER_SEC)

namespace Ment {
    template<typename T>
    T inverse(T a, T m) {
        T u = 0, v = 1;
        while (a != 0) {
            T t = m / a;
            m -= t * a;
            swap(a, m);
            u -= t * v;
            swap(u, v);
        }
        assert(m == 1);
        return u;
    }

    template<typename T>
    class Modular {
    public:
        using Type = typename decay<decltype(T::value)>::type;

        constexpr Modular() : value() {}

        template<typename U>
        Modular(const U &x) {
            value = normalize(x);
        }

        template<typename U>
        static Type normalize(const U &x) {
            Type v;
            if (-mod() <= x && x < mod()) v = static_cast<Type>(x);
            else v = static_cast<Type>(x % mod());
            if (v < 0) v += mod();
            return v;
        }

        const Type &operator()() const { return value; }

        template<typename U>
        explicit operator U() const { return static_cast<U>(value); }

        constexpr static Type mod() { return T::value; }

        Modular &operator+=(const Modular &other) {
            value += other.value - mod();
            value += (value >> 31) & mod();
            return *this;
        }

        Modular &operator-=(const Modular &other) {
            value -= other.value;
            value += (value >> 31) & mod();
            return *this;
        }

        template<typename U>
        Modular &operator+=(const U &other) { return *this += Modular(other); }

        template<typename U>
        Modular &operator-=(const U &other) { return *this -= Modular(other); }

        Modular &operator++() { return *this += 1; }

        Modular &operator--() { return *this -= 1; }

        Modular operator++(int) {
            Modular result(*this);
            *this += 1;
            return result;
        }

        Modular operator--(int) {
            Modular result(*this);
            *this -= 1;
            return result;
        }

        Modular operator-() const { return Modular(-value); }

        template<typename U = T>
        typename enable_if<is_same<typename Modular<U>::Type, int>::value, Modular>::type &
        operator*=(const Modular &rhs) {
#ifdef _WIN32
            uint64_t x = static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value);
            uint32_t xh = static_cast<uint32_t>(x >> 32), xl = static_cast<uint32_t>(x), d, m;
            asm(
            "divl %4; \n\t"
            : "=a" (d), "=d" (m)
            : "d" (xh), "a" (xl), "r" (mod())
            );
            value = m;
#else
            value = normalize(static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value));
#endif
            return *this;
        }

        template<typename U = T>
        typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value, Modular>::type &
        operator*=(const Modular &rhs) {
            int64_t q = static_cast<int64_t>(static_cast<long double>(value) * rhs.value / mod());
            value = normalize(value * rhs.value - q * mod());
            return *this;
        }

        template<typename U = T>
        typename enable_if<!is_integral<typename Modular<U>::Type>::value, Modular>::type &
        operator*=(const Modular &rhs) {
            value = normalize(value * rhs.value);
            return *this;
        }

        Modular &operator/=(const Modular &other) { return *this *= Modular(inverse(other.value, mod())); }

        template<typename U>
        friend bool operator==(const Modular<U> &lhs, const Modular<U> &rhs);

        template<typename U>
        friend bool operator<(const Modular<U> &lhs, const Modular<U> &rhs);

        template<typename U>
        friend std::istream &operator>>(std::istream &stream, Modular<U> &number);

    private:
        Type value;
    };

    template<typename T>
    bool operator==(const Modular<T> &lhs, const Modular<T> &rhs) { return lhs.value == rhs.value; }

    template<typename T, typename U>
    bool operator==(const Modular<T> &lhs, U rhs) { return lhs == Modular<T>(rhs); }

    template<typename T, typename U>
    bool operator==(U lhs, const Modular<T> &rhs) { return Modular<T>(lhs) == rhs; }

    template<typename T>
    bool operator!=(const Modular<T> &lhs, const Modular<T> &rhs) { return !(lhs == rhs); }

    template<typename T, typename U>
    bool operator!=(const Modular<T> &lhs, U rhs) { return !(lhs == rhs); }

    template<typename T, typename U>
    bool operator!=(U lhs, const Modular<T> &rhs) { return !(lhs == rhs); }

    template<typename T>
    bool operator<(const Modular<T> &lhs, const Modular<T> &rhs) { return lhs.value < rhs.value; }

    template<typename T>
    Modular<T> operator+(const Modular<T> &lhs, const Modular<T> &rhs) { return Modular<T>(lhs) += rhs; }

    template<typename T, typename U>
    Modular<T> operator+(const Modular<T> &lhs, U rhs) { return Modular<T>(lhs) += rhs; }

    template<typename T, typename U>
    Modular<T> operator+(U lhs, const Modular<T> &rhs) { return Modular<T>(lhs) += rhs; }

    template<typename T>
    Modular<T> operator-(const Modular<T> &lhs, const Modular<T> &rhs) { return Modular<T>(lhs) -= rhs; }

    template<typename T, typename U>
    Modular<T> operator-(const Modular<T> &lhs, U rhs) { return Modular<T>(lhs) -= rhs; }

    template<typename T, typename U>
    Modular<T> operator-(U lhs, const Modular<T> &rhs) { return Modular<T>(lhs) -= rhs; }

    template<typename T>
    Modular<T> operator*(const Modular<T> &lhs, const Modular<T> &rhs) { return Modular<T>(lhs) *= rhs; }

    template<typename T, typename U>
    Modular<T> operator*(const Modular<T> &lhs, U rhs) { return Modular<T>(lhs) *= rhs; }

    template<typename T, typename U>
    Modular<T> operator*(U lhs, const Modular<T> &rhs) { return Modular<T>(lhs) *= rhs; }

    template<typename T>
    Modular<T> operator/(const Modular<T> &lhs, const Modular<T> &rhs) { return Modular<T>(lhs) /= rhs; }

    template<typename T, typename U>
    Modular<T> operator/(const Modular<T> &lhs, U rhs) { return Modular<T>(lhs) /= rhs; }

    template<typename T, typename U>
    Modular<T> operator/(U lhs, const Modular<T> &rhs) { return Modular<T>(lhs) /= rhs; }

    template<typename T, typename U>
    Modular<T> pow(const Modular<T> &a, const U &b) {
        assert(b >= 0);
        Modular<T> x = a, res = 1;
        U p = b;
        while (p > 0) {
            if (p & 1) res *= x;
            x *= x;
            p >>= 1;
        }
        return res;
    }

    template<typename T>
    string to_string(const Modular<T> &number) {
        return to_string(number());
    }

    template<typename T>
    std::ostream &operator<<(std::ostream &stream, const Modular<T> &number) {
        return stream << number();
    }

    template<typename T>
    std::istream &operator>>(std::istream &stream, Modular<T> &number) {
        typename common_type<typename Modular<T>::Type, int64_t>::type x;
        stream >> x;
        number.value = Modular<T>::normalize(x);
        return stream;
    }

    constexpr int md = 998244353;
    using Mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>;
}
//using Ment::Mint;
using namespace Ment;

const int maxn = 2e5 + 100, inf = 1e9 + 100;

namespace descent_segtree {
    struct item {
        ll set = -1, add = 0, r = 0;
    };

    vector<item> q;

    int N;

    void init(int n) {
        N = 1;
        while (N < n)
            N *= 2;
        q.assign(2 * N, {});
    }

    // w = (set) + (add)

    void save(int v, ll set, ll add) {
        if (set != -1) {
            q[v].set = q[v].r = set;
            q[v].add = 0;
        }
        if (add != 0) {
            q[v].add += add;
            q[v].r += add;
        }
    }

    void push(int v) {
        save(2 * v, q[v].set, q[v].add);
        save(2 * v + 1, q[v].set, q[v].add);
        q[v].set = -1;
        q[v].add = 0;
    }

    void calc(int v) {
        q[v].r = q[2 * v + 1].r;
    }

    void modify(int v, int tl, int tr, int l, int r, pair<ll, ll> w) {
        if (l > r)
            return;
        if (tl == l && tr == r) {
            save(v, w.fr, w.sc);
            return;
        }
        assert(tl != tr);
        push(v);
        int m = (tl + tr) / 2;
        modify(2 * v, tl, m, l, min(r, m), w);
        modify(2 * v + 1, m + 1, tr, max(l, m + 1), r, w);
        calc(v);
    }

    // last equal
    int get_last(int v, int tl, int tr, int r, ll w) {
        if (tl == tr)
            return tl;
        push(v);
        int m = (tl + tr) / 2;
        if (r <= m || q[2 * v].r == w)
            return get_last(2 * v, tl, m, r, w);
        return get_last(2 * v + 1, m + 1, tr, r, w);
    }

    // first >= w
    int get_first(int v, int tl, int tr, int l, ll w) {
        if (tl == tr) {
            return q[v].r >= w ? tr : -1;
        }
        push(v);
        int m = (tl + tr) / 2;
        if (l <= m && q[2 * v].r >= w)
            return get_first(2 * v, tl, m, l, w);
        return get_first(2 * v + 1, m + 1, tr, l, w);
    }

    ll get(int v, int l, int r, int i) {
        if (l == r)
            return q[v].r;
        push(v);
        int m = (l + r) / 2;
        if (i <= m)
            return get(2 * v, l, m, i);
        return get(2 * v + 1, m + 1, r, i);
    }

    void set_value(int l, int r, ll w) {
        modify(1, 0, N - 1, l, r, {w, 0});
    }

    void add_value(int l, int r, ll w) {
        modify(1, 0, N - 1, l, r, {-1, w});
    }

    ll get_value(int i) {
        return get(1, 0, N - 1, i);
    }

    int last_equal(int r, ll w) {
        return get_last(1, 0, N - 1, r, w);
    }

    int first_atleast(int l, ll w) {
        return get_first(1, 0, N - 1, l, w);
    }
}

namespace segtree_lazy {
    struct item {
        Mint w = 0, u = 0;
        bool hasu = 0;

        template<typename T>
        void init(const T &t, int l, int r) {
            w = t;
            hasu = 0;
        }

        void update(const item &first, const item &second, int l, int r) {
            w = first.w + second.w;
        }

        static item merge(const item &first, const item &second, int l, int r) {
            item res;
            res.update(first, second, l, r);  // careful with different lengths
            return res;
        }

        template<typename Modifier>
        void modify(const Modifier &m, int l, int r) {
            w = (r - l + 1) * Mint(m);
            u = m;
            hasu = 1;
        }

        void push(item &first, item &second, int l, int r) {
            if (hasu) {
                int m = (l + r) / 2;
                first.modify(u, l, m);
                second.modify(u, m + 1, r);
                hasu = 0;
            }
        }
    };

    struct segtree {
        vector<item> tree;
        int n = 1;

        segtree(int n = 1) : n(n) {
            tree.resize(1 << (__lg(max(1, n - 1)) + 2));
        }

        template<typename T>
        segtree(const vector<T> &v) {
            build(v);
        }

        template<typename T>
        void build(const vector<T> &v, int i, int l, int r) {
            if (l == r) {
                tree[i].init(v[l], l, r);
                return;
            }
            int m = (l + r) >> 1;
            build(v, i * 2 + 1, l, m);
            build(v, i * 2 + 2, m + 1, r);
            tree[i].update(tree[i * 2 + 1], tree[i * 2 + 2], l, r);
        }

        template<typename T>
        void build(const vector<T> &v) {
            n = v.size();
            tree.assign(1 << (__lg(max(1, n - 1)) + 2), item());
            build(v, 0, 0, n - 1);
        }

        item ask(int l, int r, int i, int vl, int vr) {
            if (vl != vr) {
                tree[i].push(tree[i * 2 + 1], tree[i * 2 + 2], vl, vr);
            }
            if (l == vl && r == vr) {
                return tree[i];
            }
            int m = (vl + vr) >> 1;
            if (r <= m) {
                return ask(l, r, i * 2 + 1, vl, m);
            } else if (m < l) {
                return ask(l, r, i * 2 + 2, m + 1, vr);
            } else {
                return item::merge(ask(l, m, i * 2 + 1, vl, m), ask(m + 1, r, i * 2 + 2, m + 1, vr), l, r);
            }
        }

        item ask(int l, int r) {
            l = max(l, 0);
            r = min(r, n - 1);
            if (l > r) return item();
            return ask(l, r, 0, 0, n - 1);
        }

        template<typename T>
        void set(int ind, const T &t) {
            static array<pair<int, int>, 30> st;
            int l = 0, r = n - 1, i = 0;
            int ptr = -1;
            while (l != r) {
                if (l != r) {
                    tree[i].push(tree[i * 2 + 1], tree[i * 2 + 2], l, r);
                }
                st[++ptr] = {l, r};
                int m = (l + r) >> 1;
                if (ind <= m) {
                    i = i * 2 + 1;
                    r = m;
                } else {
                    i = i * 2 + 2;
                    l = m + 1;
                }
            }
            tree[i].init(t, l, r);
            while (i != 0) {
                i = (i - 1) / 2;
                tree[i].update(tree[i * 2 + 1], tree[i * 2 + 2], st[ptr].first, st[ptr].second);
                --ptr;
            }
        }

        template<typename Modifier>
        void modify(int l, int r, const Modifier &modifier, int i, int vl, int vr) {
            if (vl != vr) {
                tree[i].push(tree[i * 2 + 1], tree[i * 2 + 2], vl, vr);
            }
            if (l == vl && r == vr) {
                tree[i].modify(modifier, vl, vr);
                return;
            }
            int m = (vl + vr) >> 1;
            if (r <= m) {
                modify(l, r, modifier, i * 2 + 1, vl, m);
            } else if (m < l) {
                modify(l, r, modifier, i * 2 + 2, m + 1, vr);
            } else {
                modify(l, m, modifier, i * 2 + 1, vl, m);
                modify(m + 1, r, modifier, i * 2 + 2, m + 1, vr);
            }
            tree[i].update(tree[i * 2 + 1], tree[i * 2 + 2], vl, vr);
        }

        template<typename Modifier>
        void modify(int l, int r, const Modifier &modifier) {
            l = max(l, 0);
            r = min(r, n - 1);
            if (l > r) return;
            modify(l, r, modifier, 0, 0, n - 1);
        }
    };


}

void solve() {
    int nig, m;
    cin >> m >> nig;
    segtree_lazy::segtree cnts(nig + 1);
    descent_segtree::init(nig + 1);
    cnts.modify(0, 0, 1);
    for (int it = 0; it < m; it++) {
        int l, r, c;
        cin >> l >> r >> c;
        ll l_value = descent_segtree::get_value(l);
        int left_pos = descent_segtree::last_equal(l, l_value);
        Mint l_cnt = cnts.ask(left_pos, l).w;
        cnts.set(l, l_cnt);
        descent_segtree::add_value(l, r, c);
        ll r_value = descent_segtree::get_value(r);
        int right_pos = descent_segtree::first_atleast(r + 1, r_value);
        if (right_pos == -1)
            right_pos = descent_segtree::N;
//        cerr << l_value << ' ' << left_pos << ' ' << l_cnt << ' ' << r_value << ' ' << right_pos << '\n';
        if (r + 1 <= right_pos - 1) {
            descent_segtree::set_value(r + 1, right_pos - 1, r_value);
            cnts.modify(r + 1, right_pos - 1, 0);
        }
//        for (int i = 0; i <= nig; i++)
//            cerr << descent_segtree::get_value(i) << ',' << cnts.ask(i, i).w << ' ';
//        cerr << '\n';
    }
    ll ans = descent_segtree::get_value(nig);
    int left_pos = descent_segtree::last_equal(nig, ans);
    Mint cnt = cnts.ask(left_pos, nig).w;
    cout << ans << ' ' << cnt << '\n';
}
// check test counter

int main() {
#ifdef ONPC
    freopen("../a.in", "r", stdin);
    freopen("../a.out", "w", stdout);
#endif
    ios::sync_with_stdio(0);
    cin.tie(0);
    int ts;
    ts = 1;
    cin >> ts;
    for (int its = 1; its <= ts; its++)
        solve();
}