#ifndef ONLINE_JUDGE
#define _GLIBCXX_DEBUG
#endif
#include <bits/stdc++.h>
using namespace std;

#define pass (void)0
#define INF (1<<30)-1
#define INFLL (1LL<<60)-1
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repr(i, n) for (int i = (int)(n) - 1; i >= 0; i--)
#define rep2(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define repr2(i, a, b) for (int i = (int)(b) - 1; i >= (int)(a); i--)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define sz(x) ((int)(x).size())
#define YesNo(cond) cout << ((cond) ? "Yes\n" : "No\n")
#define YESNO(cond) cout << ((cond) ? "YES\n" : "NO\n")

using ll = long long;
using pii = pair<int,int>;
using pll = pair<ll,ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vvl = vector<vl>;

template <typename T> void print(const T& value) { cout << value << "\n"; }
template <typename T> void print(const vector<T>& vec) { for (auto& v : vec) cout << v << " "; cout << "\n"; }
template <typename T> void input(vector<T>& vec) { for (auto& v : vec) cin >> v; };
template <typename T> bool chmin(T& a, const T& b) { if (a > b) { a = b; return true; } return false; }
template <typename T> bool chmax(T& a, const T& b) { if (a < b) { a = b; return true; } return false; }

#include <atcoder/all>
using namespace atcoder;
using mint = modint998244353;
using vm = vector<mint>;

// 区間変更・区間和取得
struct S{
    ll value;
    int size;
};
S op(S a, S b){ return {a.value+b.value, a.size+b.size}; }
S e(){ return {0, 0}; }
S mapping(ll f, S x){
    if(f != INFLL) x.value = f*x.size;
    return x;
}
ll composition(ll f, ll g){ return (f == INFLL ? g : f); }
ll id(){ return INFLL; }

bool bisect(S res) {
    return res.value == 0;
}

template<typename T>
vector<T> compress(vector<T> A) {
    sort(A.begin(), A.end());
    A.erase(unique(A.begin(), A.end()), A.end());
    return A;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout << fixed << setprecision(10);

    ll N, Q;
    cin >> N >> Q;

    vvl query;
    vl A;
    rep (_, Q) {
        ll t; cin >> t;
        if (t == 1) {
            ll L, R;
            cin >> L >> R;
            L --; R --;
            query.push_back({t, L, R});
            A.push_back(L);
            A.push_back(L-1);
            A.push_back(L+1);
            A.push_back(R);
            A.push_back(R-1);
            A.push_back(R+1);
        } else if (t == 2) {
            ll L, R;
            cin >> L >> R;
            L --; R --;
            query.push_back({t, L, R});
            A.push_back(L);
            A.push_back(L-1);
            A.push_back(L+1);
            A.push_back(R);
            A.push_back(R-1);
            A.push_back(R+1);
        } else if (t == 3) {
            ll u, v;
            cin >> u >> v;
            u --; v --;
            query.push_back({t, u, v});
            A.push_back(u);
            A.push_back(u-1);
            A.push_back(u+1);
            A.push_back(v);
            A.push_back(v-1);
            A.push_back(v+1);
        } else {
            ll v;
            cin >> v;
            v --;
            query.push_back({t, v});
            A.push_back(v);
            A.push_back(v-1);
            A.push_back(v+1);
        }
    }
    auto B = compress(A);
    unordered_map<ll, ll> IDX;
    vl IDXR;
    rep (i, sz(B)) {
        IDX[B[i]] = i;
        IDXR.push_back(B[i]);
    }

    vector<S> def(sz(IDX), {1, 1});
    lazy_segtree<S, op, e, ll, mapping, composition, id> seg(def);
    rep (i, Q) {
        ll t = query[i][0];
        if (t == 1) {
            ll L, R;
            L = query[i][1];
            R = query[i][2];
            seg.apply(IDX[L], IDX[R], 0);
        } else if (t == 2) {
            ll L, R;
            L = query[i][1];
            R = query[i][2];
            seg.apply(IDX[L], IDX[R], 1);
        } else if (t == 3) {
            ll u, v;
            u = query[i][1];
            v = query[i][2];
            if (u > v) swap(u, v);
            auto res = seg.prod(IDX[u], IDX[v]);
            print((res.value == 0) ? 1 : 0);
        } else {
            ll v = query[i][1];
            ll l = seg.min_left<bisect>(IDX[v]);
            ll r = seg.max_right<bisect>(IDX[v]);
            ll a = (1 <= l) ? IDXR[l-1]+1 : 0;
            ll b = (r < sz(IDX)) ? IDXR[r] : N-1;
            print(b-a+1);
        }
    }
}