#include <bits/stdc++.h>
#define rep(i,j,k) for(int i=(j);i<=(k);i++)
#define per(i,j,k) for(int i=(j);i>=(k);i--)
#define uint unsigned int
#define ll long long
#define ull unsigned long long
#define db double
#define ldb long double
#define pii pair<int,int>
#define pll pair<ll,ll>
#define mkp make_pair
#define eb emplace_back
#define SZ(S) (int)S.size()
#define mod 998244353
//#define mod 1000000007
#define inf 0x3f3f3f3f
#define linf 0x3f3f3f3f3f3f3f3f
using namespace std;

template <class T>
void chkmax(T &x,T y){
    if(x < y) x = y;
}

template <class T>
void chkmin(T &x,T y){
    if(x > y) x = y;
}

inline int popcnt(int x){
    return __builtin_popcount(x);
}

inline int ctz(int x){
    return __builtin_ctz(x);
}

template <int P>
class mod_int
{
    using Z = mod_int;

private:
    static int mo(int x) { return x < 0 ? x + P : x; }

public:
    int x;
    int val() const { return x; }
    mod_int() : x(0) {}
    template <class T>
    mod_int(const T &x_) : x(x_ >= 0 && x_ < P ? static_cast<int>(x_) : mo(static_cast<int>(x_ % P))) {}
    bool operator==(const Z &rhs) const { return x == rhs.x; }
    bool operator!=(const Z &rhs) const { return x != rhs.x; }
    Z operator-() const { return Z(x ? P - x : 0); }
    Z pow(long long k) const
    {
        Z res = 1, t = *this;
        while (k)
        {
            if (k & 1)
                res *= t;
            if (k >>= 1)
                t *= t;
        }
        return res;
    }
    Z &operator++()
    {
        x < P - 1 ? ++x : x = 0;
        return *this;
    }
    Z &operator--()
    {
        x ? --x : x = P - 1;
        return *this;
    }
    Z operator++(int)
    {
        Z ret = x;
        x < P - 1 ? ++x : x = 0;
        return ret;
    }
    Z operator--(int)
    {
        Z ret = x;
        x ? --x : x = P - 1;
        return ret;
    }
    Z inv() const { return pow(P - 2); }
    Z &operator+=(const Z &rhs)
    {
        (x += rhs.x) >= P && (x -= P);
        return *this;
    }
    Z &operator-=(const Z &rhs)
    {
        (x -= rhs.x) < 0 && (x += P);
        return *this;
    }
    Z operator-()
    {
        return -x;
    }
    Z &operator*=(const Z &rhs)
    {
        x = 1ULL * x * rhs.x % P;
        return *this;
    }
    Z &operator/=(const Z &rhs) { return *this *= rhs.inv(); }
#define setO(T, o)                                  \
    friend T operator o(const Z &lhs, const Z &rhs) \
    {                                               \
        Z res = lhs;                                \
        return res o## = rhs;                       \
    }
    setO(Z, +) setO(Z, -) setO(Z, *) setO(Z, /)
#undef setO
    
    friend istream& operator>>(istream& is, mod_int& x)
    {
        long long tmp;
        is >> tmp;
        x = tmp;
        return is;
    }
    friend ostream& operator<<(ostream& os, const mod_int& x)
    {
        os << x.val();
        return os;
    }
};

using Z = mod_int<mod>;
Z power(Z p,ll k){
    Z ans = 1;
    while(k){
        if(k % 2 == 1) ans *= p;
        p *= p;
        k /= 2;
    }
    return ans;
}
int n,m;
int _op[500005],_l[500005],_r[500005];
Z P[500005];
const Z i2 = Z(1) / 2;

struct seg{
    int l,r;
    Z w;
};
bool cmp2(seg p,seg q){
    if(p.l != q.l) return p.l < q.l;
    return p.r < q.r;
}

int k;
int a[500005],idx[500005],ls[500005],rs[500005];
vector <int> sta;
void ins(int p){
    while(!sta.empty() && a[p] < a[sta.back()]){
        ls[p] = sta.back();
        sta.pop_back();
    }
    if(!sta.empty()) rs[sta.back()] = p;
    sta.eb(p);
}

int N;
int pl[500005],pr[500005],fa[500005],ST[20][500005],dfn[500005],dep[500005],_dep[2][500005];//[0] 是作为左儿子的深度
inline int cmp(int x,int y){
    if(dep[x] < dep[y]) return x;
    return y;
}

inline int qry(int l,int r){
    int x = __lg(r - l + 1);
    return cmp(ST[x][l],ST[x][r - (1 << x) + 1]);
}

inline int LCA(int u,int v){
    if(u == v) return u;
    u = dfn[u];v = dfn[v];
    if(u > v) swap(u,v);
    return fa[qry(u + 1,v)];
}
Z val[3][500005];
void dfs(int u){//管辖区间 [pl,pr],事实上第一次作为左儿子一定是作为 pr 的左儿子,作为右儿子一定是作为 pl 的右儿子
    dfn[u] = ++N;
    ST[0][N] = u;
    dep[u] = dep[fa[u]] + 1;
    _dep[0][u] = _dep[0][pr[u]] + 1;
    _dep[1][u] = _dep[1][pl[u]] + 1;
    if(ls[u]){
        pl[ls[u]] = pl[u];pr[ls[u]] = u;
        fa[ls[u]] = u;
        dfs(ls[u]);
    }
    if(rs[u]){
        pl[rs[u]] = u;pr[rs[u]] = pr[u];
        fa[rs[u]] = u;
        dfs(rs[u]);
    }
}

void dfs2(int u){
    if(ls[u]) dfs2(ls[u]);
    if(rs[u]) dfs2(rs[u]);
    val[0][pr[u]] += 2 * val[0][u];//val[0] 是给右儿子的
    val[1][pl[u]] += 2 * val[1][u];
}

vector <seg> temp;
void dfs3(int u){
    if(ls[u]){
        val[2][ls[u]] += i2 * (val[1][u] + val[2][u]);
        dfs3(ls[u]);
    }else{
        temp.push_back({pl[u],u,i2 * (val[1][u] + val[2][u])});
    }
    if(rs[u]){
        val[2][rs[u]] += i2 * (val[0][u] + val[2][u]);
        dfs3(rs[u]);
    }else{
        temp.push_back({u,pr[u],i2 * (val[0][u] + val[2][u])});
    }    
    val[0][u] = val[1][u] = val[2][u] = ls[u] = rs[u] = 0;
}

void solve(vector <seg> &ans){
    rep(i,0,SZ(sta) - 2) rs[sta[i]] = sta[i + 1];
    int rt = sta[0];sta.clear();
    pl[rt] = 0;pr[rt] = n + 1;
/*    printf("cdq\n");
    for(seg I:ans) printf("[%d,%d] %d\n",I.l,I.r,I.w.val());
    rep(i,1,k) printf("node %d ls %d rs %d\n",idx[i],ls[idx[i]],rs[idx[i]]);*/
    N = 0;
    dfs(rt);
    rep(i,1,18){
        rep(j,1,N){
            if(j + (1 << i) - 1 > N) break;
            ST[i][j] = cmp(ST[i - 1][j],ST[i - 1][j + (1 << (i - 1))]);
        }
    }

    int u,v,d;
    for(seg I:ans){
        u = upper_bound(idx + 1,idx + k + 1,I.l) - idx;
        v = lower_bound(idx + 1,idx + k + 1,I.r) - idx - 1;
        if(u > v){
            temp.push_back(I);
            continue;
        }
        u = idx[u];v = idx[v];d = LCA(u,v);
        val[0][u] += I.w * P[_dep[0][u] - _dep[0][d]];
        val[0][d] -= I.w;
        val[1][v] += I.w * P[_dep[1][v] - _dep[1][d]];
        val[1][d] -= I.w;
        temp.push_back({I.l,u,I.w * P[_dep[0][u] - _dep[0][d] + 1]});
        temp.push_back({v,I.r,I.w * P[_dep[1][v] - _dep[1][d] + 1]});
    }
    dfs2(rt);
    dfs3(rt);
    ans = temp;
    temp.clear();      
//    printf("res:\n");
//    for(seg I:ans) printf("[%d,%d] %d\n",I.l,I.r,I.w.val());
}

vector <seg> solve(int ql,int qr){
    vector <seg> ans,qwq;
    if(ql == qr){
        if(_op[ql] == 1) ans.push_back({_l[ql],_r[ql],1});
        return ans;
    }
    int mid = (ql + qr) >> 1;
    ans = solve(ql,mid);
    k = 0;
    rep(i,mid + 1,qr){
        if(_op[i] == 2 && !a[_l[i]]){
            idx[++k] = _l[i];
            a[_l[i]] = i;
        }
    }
    sort(idx + 1,idx + k + 1);
    rep(i,1,k) ins(idx[i]);
    if(!sta.empty()) solve(ans);
    rep(i,mid + 1,qr) a[_l[i]] = 0;

    qwq = solve(mid + 1,qr);
    ans.insert(ans.begin(),qwq.begin(),qwq.end());
    sort(ans.begin(),ans.end(),cmp2);
    qwq.clear();
    for(int l = 0,r;l < SZ(ans);l = r + 1){
        r = l;
        while(r + 1 < SZ(ans) && ans[r].l == ans[r + 1].l && ans[r].r == ans[r + 1].r){
            r++;
            ans[l].w += ans[r].w;
        }
        if(ans[l].l < ans[l].r && ans[l].w.val()) qwq.eb(ans[l]);
    }
    return qwq;
}

int main(){
//    freopen("test.in","r",stdin);
//    freopen("test.out","w",stdout);
    scanf("%d%d",&n,&m);
    P[0] = 1;
    rep(i,1,m) P[i] = P[i - 1] * i2;
    rep(i,1,m){
        scanf("%d",&_op[i]);
        if(_op[i] == 1){
            scanf("%d%d",&_l[i],&_r[i]);
        }else{
            scanf("%d",&_l[i]);
        }
    }
    vector <seg> res = solve(1,m);
    Z output = 0;
    for(seg I:res) output += I.w * (I.r - I.l);
    printf("%d\n",output.val());
	return 0;
}