#include<bits/stdc++.h>

using namespace std;

#define MAXN 200010

typedef long long ll;

typedef long double ld;

const int inf = 1e9;

int n , m;

template <typename T> inline void chkmax(T &x , T y) { x = max(x , y); }

template <typename T> inline void chkmin(T &x , T y) { x = min(x , y); }

template <typename T> inline void read(T &x)

{

    T f = ; x  = ;

    char c = getchar();

    for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;

    for (; isdigit(c); c = getchar()) x = (x << ) + (x << ) + c - '';

    x *= f;

}

struct Segment_Tree

{

    struct Node

    {

        int l , r;

        int lm0 , rm0 , value , cnt;

        int tag;

    } a[MAXN << ];

    inline void build(int index , int l , int r)

    {

        a[index].l = l , a[index].r = r;

        a[index].cnt = r - l + ;

        a[index].tag = -;

        if (l == r) return;

        int mid = (l + r) >> ;

        build(index <<  , l , mid);

        build(index <<  |  , mid +  , r);

    }

    inline void update(int x)

    {

        int l = a[x].l , r = a[x].r;

        int mid = (l + r) >> ;

        a[x].cnt = a[x << ].cnt + a[x <<  | ].cnt;

        if (a[x << ].lm0 == mid - l + ) a[x].lm0 = mid - l +  + a[x <<  | ].lm0;

        else a[x].lm0 = a[x << ].lm0;

        if (a[x <<  | ].rm0 == r - mid) a[x].rm0 = r - mid + a[x << ].rm0;

        else a[x].rm0 = a[x <<  | ].rm0;

        a[x].value = max(a[x << ].value , a[x <<  | ].value);

        chkmax(a[x].value , a[x << ].rm0 + a[x <<  | ].lm0);

    }

    inline void pushdown(int index)

    {

        int l = a[index].l , r = a[index].r;

        int mid = (l + r) >> ;

        if (l == r) return;

        if (a[index].tag == )

        {

            a[index << ].cnt = a[index <<  | ].cnt = ;

            a[index << ].value = mid - l + ;

            a[index <<  | ].value = r - mid;

            a[index << ].lm0 = a[index << ].rm0 = mid - l + ;

            a[index <<  | ].lm0 = a[index <<  | ].rm0 = r - mid;

            a[index << ].tag = a[index <<  | ].tag = a[index].tag;

            a[index].tag = -;

        }

        if (a[index].tag == )

        {

            a[index << ].cnt = mid - l + ;

            a[index <<  | ].cnt = r - mid;

            a[index << ].value = a[index <<  | ].value = ;

            a[index << ].lm0 = a[index << ].rm0 = ;

            a[index <<  | ].lm0 = a[index <<  | ].rm0 = ;

            a[index << ].tag = a[index <<  | ].tag = a[index].tag;

            a[index].tag = -;

        }

    }

    inline void modify(int index , int l , int r)

    {

        if (a[index].l == l && a[index].r == r)

        {

            a[index].cnt = ;

            a[index].lm0 = a[index].rm0 = r - l + ;

            a[index].value = r - l + ;

            a[index].tag = ;

            return;

        }

        pushdown(index);

        int mid = (a[index].l + a[index].r) >> ;

        if (mid >= r) modify(index <<  , l , r);

        else if (mid +  <= l) modify(index <<  |  , l , r);

        else

        {

            modify(index <<  , l , mid);

            modify(index <<  |  , mid +  , r);

        }

        update(index);

    }

    inline int queryA(int index , int l , int r)

    {

            if (a[index].l == l && a[index].r == r)

                    return a[index].cnt;

            pushdown(index);

            int mid = (a[index].l + a[index].r) >> ;

            if (mid >= r) return queryA(index <<  , l , r);

            else if (mid +  <= l) return queryA(index <<  |  , l , r);

            else return queryA(index <<  , l , mid) + queryA(index <<  |  , mid +  , r);

        }

        inline int queryB(int index , int l , int r)

    {

        if (a[index].l == l && a[index].r == r)

            return a[index].value;

        pushdown(index);

        int mid = (a[index].l + a[index].r) >> ;

        if (mid >= r) return queryB(index <<  , l , r);

        else if (mid +  <= l) return queryB(index <<  |  , l , r);

        {

                      int ret = max(queryB(index <<  , l , mid) , queryB(index <<  |  , mid +  , r));

            chkmax(ret , min(mid - l +  , a[index << ].rm0) + min(r - mid , a[index <<  | ].lm0));

            return ret;

        }

    }

    inline void change(int index , int l , int r)

    {

            if (l > r) return;

                 if (a[index].l == l && a[index].r == r)

                 {

                         a[index].cnt = r - l + ;

                        a[index].lm0 = a[index].rm0 = a[index].value = ;

                        a[index].tag = ;

                        return;

                }

                pushdown(index);

                int mid = (a[index].l + a[index].r) >> ;

                if (mid >= r) change(index <<  , l , r);

                else if (mid +  <= l) change(index <<  |  , l , r);

                else

                {

                        change(index <<  , l , mid);

                        change(index <<  |  , mid +  , r);

                }

                update(index);

    }

} SGT;

int main()

{

    read(n); read(m);

    SGT.build( ,  , n);

    for (int i = ; i <= m; i++)

    {

        int type;

        read(type);

        if (type == )

        {

            int x , y;

            read(x); read(y);

            SGT.modify( , x , y);

        } else if (type == )

        {

            int l0 , r0 , l1 , r1;

            read(l0); read(r0); read(l1); read(r1);

            int cnt = SGT.queryA( , l0 , r0);

            SGT.modify( , l0 , r0);

            int l = l1 , r = r1 , loc = ;

            while (l <= r)

            {

                    int mid = (l + r) >> ;

                    if ((mid - l1 + ) - SGT.queryA( , l1 , mid) <= cnt)

                    {

                            loc = mid;

                            l = mid + ;

                                } else r = mid - ;

                        }

            SGT.change( , l1 , loc);

        } else

        {

            int l , r;

            read(l); read(r);

            printf("%d\n" , SGT.queryB( , l , r));

        }

    }

    return ;

}