#include <cstdio>

#include <cstring>

using namespace std;

const int N = 3e5 + ;

int n, qn, a[N];

inline void read(int &X) {

    X = ;

    char ch = ;

    int op = ;

    for(; ch > '' || ch < ''; ch = getchar())

        if(ch == '-') op = -;

    for(; ch >= '' && ch <= ''; ch = getchar())

        X = (X << ) + (X << ) + ch - ;

    X *= op;

} 

struct Node {

    int lc, rc, sum;

};

namespace PSegT {

    int root[N], nodeCnt;

    Node s[N * ];

    #define mid ((l + r) >> 1)

    void up(int p) {

        if(p) s[p].sum = s[s[p].lc].sum + s[s[p].rc].sum;

    }

    void ins(int &p, int l, int r, int x) {

        if(!p) p = ++nodeCnt;

        if(l == x && x == r) {

            s[p].sum++;

            return;

        }

        if(x <= mid) ins(s[p].lc, l, mid, x);

        else ins(s[p].rc, mid + , r, x);

        up(p);

    }

    void del(int &p, int l, int r, int x) {

        if(l == x && x == r) {

            s[p].sum--;

            if(s[p].sum == ) p = ;

            return;

        }

        if(x <= mid) del(s[p].lc, l, mid, x);

        else del(s[p].rc, mid + , r, x);

        up(p);

        if(!s[p].lc && !s[p].rc && !s[p].sum) p = ;

    } 

    int query(int p, int l, int r, int x, int y) {

        if(!p) return ;

        if(x <= l && y >= r) return s[p].sum;

        int res = ;

        if(x <= mid) res += query(s[p].lc, l, mid, x, y);

        if(y > mid) res += query(s[p].rc, mid + , r, x, y);

        return res;

    }

} using namespace PSegT;

inline void swap(int &x, int &y) {

    int t = x;

    x = y;

    y = t;

}

int main() {

    read(n), read(qn);

    nodeCnt = ;

    for(int i = ; i <= n; i++) {

        read(a[i]);

        ins(root[a[i]], , n, i);

    }

    for(int op; qn--; ) {

        read(op);

        if(op == ) {

            int x, y, c;

            read(x), read(y), read(c);

            printf("%d\n", query(root[c], , n, x, y));

        } else {

            int x;

            read(x);

            del(root[a[x]], , n, x);

            del(root[a[x + ]], , n, x + );

            swap(a[x], a[x + ]);

            ins(root[a[x]], , n, x);

            ins(root[a[x + ]], , n, x + );

        }

    }

    return ;

}