#include <cstdio>

#include <cstring>

#include <algorithm>

using namespace std;

typedef long long ll;

const int N = 5e4 + ;

int n, qn, mn, tot = ;

ll val[N];

struct Querys {

    int type, l, r;

    ll k;

} q[N];

template <typename T>

inline void read(T &X) {

    X = ; char ch = ; T op = ;

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

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

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

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

    X *= op;

}

namespace SegT {

    struct Node {

        int lc, rc, tag;

        ll sum;

    } s[N * ];

    int root[N << ], nodeCnt = ;

    #define lc(p) s[p].lc

    #define rc(p) s[p].rc

    #define sum(p) s[p].sum

    #define tag(p) s[p].tag

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

    inline void up(int p) {

        if(!p) return;

        sum(p) = sum(lc(p)) + sum(rc(p));

    }

    inline void down(int p, int l, int r) {

        if(!tag(p)) return;

        if(!lc(p)) lc(p) = ++nodeCnt;

        if(!rc(p)) rc(p) = ++nodeCnt;

        sum(lc(p)) += 1LL * tag(p) * (mid - l + ), tag(lc(p)) += tag(p);

        sum(rc(p)) += 1LL * tag(p) * (r - mid), tag(rc(p)) += tag(p);

        tag(p) = ;

    }

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

        if(!p) p = ++nodeCnt;

        if(x <= l && y >= r) {

            ++tag(p);

            sum(p) += 1LL * (r - l + );

            return;

        }

        down(p, l, r);

        if(x <= mid) ins(lc(p), l, mid, x, y);

        if(y > mid) ins(rc(p), mid + , r, x, y);

        up(p);

    }

    ll getSum(int p, int l, int r, int x, int y) {

        if(!p) return 0LL;

        if(x <= l && y >= r) return sum(p);

        down(p, l, r);

        ll res = 0LL;

        if(x <= mid) res += getSum(lc(p), l, mid, x, y);

        if(y > mid) res += getSum(rc(p), mid + , r, x, y);

        return res;

    }

    void modify(int p, int l, int r, int x, int y, int v) {

        ins(root[p], , n, x, y);

        if(l == r) return;

        if(v <= mid) modify(p << , l, mid, x, y, v);

        else modify(p <<  | , mid + , r, x, y, v);

    }

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

        if(l == r) return l;

        ll now = getSum(root[p <<  | ], , n, x, y);

        if(now >= k) return query(p <<  | , mid + , r, x, y, k);

        else return query(p << , l, mid, x, y, k - now);

    }

} using namespace SegT;

int main() {

    read(n), read(qn);

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

        read(q[i].type), read(q[i].l), read(q[i].r), read(q[i].k);

        if(q[i].type == ) val[++tot] = q[i].k;

    }

    sort(val + , val + tot + );

    tot = unique(val + , val +  + tot) - val - ;

    mn = tot;

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

        if(q[i].type == ) {

            int v = lower_bound(val + , val +  + tot, q[i].k) - val;

            modify(, , mn, q[i].l, q[i].r, v);

        } else printf("%lld\n", val[query(, , mn, q[i].l, q[i].r, q[i].k)]);

    }

    return ;

}