//#include<fstream>
#include<iostream>
#include<vector>
#include<queue>

using namespace std;
typedef int var;

//ifstream cin("graphwars.in");
//ofstream cout("graphwars.out");

#define MAXN 100001
#define INF 100000001

struct Node {
    var n;
    var i;
    Node (var a, var b) {
        n = a;
        i = b;
    }
    const bool operator <(const Node &a) const {
        return n < a.n;
    }
    const bool operator >(const Node &a) const {
        return n > a.n;
    }

    Node() {}
};



priority_queue<Node, vector<Node>, greater<Node> > G_MIN[MAXN];
priority_queue<Node, vector<Node>, less<Node> > G_MAX [MAXN];

vector<bool> REMOVED;
vector<Node> E;


void remove(var i) {
    REMOVED[i] = 1;
}

var get_min(var i) {

    Node node = G_MIN[i].top();
    if(REMOVED[node.i]) {
        G_MIN[i].pop();
        return get_min(i);
    }
    return node.n;
}

var get_max(var i) {
    Node node = G_MAX[i].top();
    if(REMOVED[node.i]) {
        G_MAX[i].pop();
        return get_max(i);
    }
    return node.n;
}

void AddEdge(var a, var b, var i) {
    G_MIN[a].push(Node(b, i));
    G_MAX[a].push(Node(b, i));
}


var MIN_TREE[2*MAXN], MAX_TREE[2*MAXN];

void update(var node, var b, var e, var poz) {
    if(b == e)  {
        MIN_TREE[node] = get_min(poz);
        MAX_TREE[node] = get_max(poz);
    }
    else {
        var m = (b+e)/2;
        if(poz <= m)
            update(node*2, b, m, poz);
        else
            update(node*2+1, m+1, e, poz);
        MIN_TREE[node] = min(MIN_TREE[node*2], MIN_TREE[node*2+1]);
        MAX_TREE[node] = max(MAX_TREE[node*2], MAX_TREE[node*2+1]);
    }
}

pair<var, var> query(var node, var b, var e, var l, var r) {
    if(b >= l && e <= r) {
        return make_pair(MIN_TREE[node], MAX_TREE[node]);
    }
    if(b >= r || e <= l) {
        return make_pair(INF, -INF);
    }
    else {
        var m = (b+e)/2;
        pair<var, var> r1 = query(node*2, b, m, l, r);
        pair<var, var> r2 = query(node*2+1, m+1, e, l, r);

        return make_pair(min(r1.first, r2.first), max(r1.second, r2.second));
    }
}

void show(var node, var b, var e, var poz) {
    if(b == e)  {
        cout<<"\n\n"<<MIN_TREE[node]<<" "<<MAX_TREE[node];

    }
    else {
        var m = (b+e)/2;
        if(poz <= m)
            show(node*2, b, m, poz);
        else
            show(node*2+1, m+1, e, poz);
    }
}




int main() {

    var n, m, a, b, type;

    E.resize(1);
    REMOVED.resize(1);

    cin>>n>>m;

    for(var i=1; i<=n; i++) {
        AddEdge(i, i, 0);
    }

    for(var i=1; i<=2*n; i++) {
        MIN_TREE[i] = INF;
        MAX_TREE[i] = -INF;
    }

    while(m--) {
        cin>>type;
        if(type == 4) {
            cin>>a;
            show(1, 1, n, a);
            continue;
        }
        if(type == 1) {
            cin>>a>>b;
            E.push_back(Node(a, b));
            REMOVED.push_back(0);
            AddEdge(a, b, E.size() - 1);
            AddEdge(b, a, E.size() - 1);

            update(1, 1, n, a);
            update(1, 1, n, b);

        } else if(type == 2) {
            cin>>a;
            remove(a);
            update(1, 1, n, E[a].n);
            update(1, 1, n, E[a].i);
        } else {
            cin>>a>>b;
            pair<var, var> res = query(1, 1, n, a, b);
            if(res.first >= a && res.second <= b) {
                cout<<"YES\n";
            } else {
                cout<<"NO\n";
            }
        }
    }

    return 0;
}