#include <bits/stdc++.h>
#define all(x) (x).begin(),(x).end()
using namespace std;

using ll = long long;
using ld = long double;

//#define int ll
#define sz(x) ((int)(x).size())

using pii = pair<int,int>;
using tii = tuple<int,int,int>;

const int inf = 1e9 + 6, nmax = 5e4 + 5;

const int mod = 998244353;
struct Mint {
  int val;
  Mint(ll x = 0): val((x % mod + mod) % mod) {;}
  Mint operator +(const Mint& x) const { return Mint(val + x.val); }
  Mint operator -(const Mint& x) const { return Mint(val - x.val); }
  Mint operator *(const Mint& x) const { return Mint((ll)val * x.val); }
  Mint operator +=(const Mint& x) { return *this = Mint(val + x.val); }
  Mint operator -=(const Mint& x) { return *this = Mint(val - x.val); }
  Mint operator *=(const Mint& x) { return *this = Mint((ll)val * x.val); }
  Mint operator ^(const int& _b) const {
    Mint accum = 1, a = *this;
    if(val == 2 && _b == mod - 2) return (mod + 1) / 2;
    int b = _b;
    while(b) {
      accum = (b & 1? accum * a : accum);
      a *= a;
      b >>= 1;
    }
    return accum;
  }
  Mint operator /(const Mint& x) { return Mint((ll)val * (x ^ (mod - 2)).val); }
  Mint operator /=(const Mint& x) { return *this = Mint((ll)val * (x ^ (mod - 2)).val); }
};
Mint ip2[nmax], p2[nmax];


struct Segm { int l, r; Mint prob; };

vector<Segm> brutOver(vector<tii> oper) { // lumea nu este gata pentru a aprecia frumusetea acestui brut (gen, cand tineam mapuri pe bucati); bucatile se schimba conform timpului
                                          // tot le-as normaliza cu radix sau cv
   vector<Segm> open;
   for(auto [t, a, b] : oper) {
      if(t == 1)
         open.emplace_back(a, b, 1);
      else {
         const int X = a;         
         int D = sz(open);
         for(int i = 0; i < D; i++) {
            auto [l, r, P] = open[i];
            if(l < X && X < r) {
               P /= 2;
               open.emplace_back(X, r, P);
               open[i].r = X;
               open[i].prob /= 2;
            }
         }
      }
   }
   
   return open;
}

Mint extbatch(int cmax, vector<Segm> segm, vector<int> wcuts) {
   
   vector<int> cut(cmax + 1, 0);
   for(int i = 0; i < sz(wcuts); i++) {
      int x = wcuts[i];
      if(cut[x] == 0) cut[x] = i + 1;
   }
   
   vector<Mint> rez(sz(segm));
   vector<bool> fals(sz(segm), 1);
   int n = sz(segm);
   
   auto sweep = [&]() {
      vector<pair<int, Mint>> st;
      vector<Mint> spart;
      cut[0] = -inf;
      st.emplace_back(0, 0);
      spart.emplace_back(0);
      
      vector<vector<pii>> qs(cmax + 1, vector<pii>());
      int II = 0;
      for(auto [l, r, P] : segm)
         qs[r].emplace_back(l, II++);
      
      for(int i = 1; i <= cmax; i++) {
         bool revert = 0;
         if(cut[i] == 0)
            revert = 1;
         
         Mint sum = i - st.back().first;
         spart.emplace_back(spart.back() + sum * ip2[sz(st) - 1]);
         st.emplace_back(i, sum);
         
         for(auto [l, idx] : qs[i]) {
            auto it = distance(st.begin(), upper_bound(all(st), make_pair(l, Mint(0)), [&](pair<int, Mint> a, pair<int, Mint> b) { return a.first < b.first; })) - 1;
            
            if(it + 1 != spart.size() - 1) fals[idx] = 0;
            
            rez[idx] += (spart.back() - spart[it + 1]) * p2[it];
         }
         
         if(revert) {
            st.pop_back();
            spart.pop_back();
         }
         else {
            st.pop_back();
            spart.pop_back();
            while(cut[i] < cut[st.back().first]) {
               sum = sum / 2 + st.back().second / 2;
               st.pop_back();
               spart.pop_back();
            }
            spart.emplace_back(spart.back() + sum * ip2[sz(st)]);
            st.emplace_back(i, sum);
         }
      }
   };
   
   sweep();
   for(auto& [l, r, P] : segm) {
      r = cmax - r + 1;
      l = cmax - l + 1;
      swap(l, r);
   }
   reverse(cut.begin() + 1, cut.begin() + cmax + 1);
   sweep();
   
   Mint total;
   for(int i = 0; i < n; i++) {
      total += rez[i] * segm[i].prob;
      if(fals[i]) total += Mint(segm[i].r - segm[i].l) * segm[i].prob;
   }
   return total;
}

vector<int> rev(vector<int> D) {
   reverse(all(D));
   return D;
}

signed main() {
   ip2[0] = 1;
   p2[0] = 1;
   for(int i = 1; i < nmax; i++)
      ip2[i] = ip2[i - 1] * ((mod + 1) / 2),
      p2[i] = p2[i - 1] * 2;
      
   cin.tie(0) -> sync_with_stdio(0);
   int n, q;
   cin >> n >> q;
   
   vector<tii> oper(q);
   vector<int> cuts;
   for(auto &[t, l, r] : oper) {
      cin >> t >> l; 
      if(t == 1) cin >> r;
      else cuts.emplace_back(l);
   }
   reverse(all(cuts));
   
   auto R = brutOver(oper);
   
   Mint rez = 0;
   
   vector<tii> currst;
   const int B = 500;
   for(auto [t, l, r] : oper) {
      currst.emplace_back(t, l, r);
      if(t == 2) cuts.pop_back();
      if(sz(currst) >= B) {
         rez += extbatch(n, brutOver(currst), rev(cuts));
         currst.clear();
      }
   }
   
   rez += extbatch(n, brutOver(currst), rev(cuts));
   cout << rez.val << '\n';
}

/**
      Istenem! Nu poate fi real.
-- Surse verificate
*/