//#define LOCAL

#include <fstream>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <vector>
#include <map>
#include <queue>
#include <cstring>
#include <climits>
#include <set>

//#define int long long
typedef long long ll;
//using ll = long long;
//using R = double;

//#define rep(i,n) for(int i=0; i<(n); i++)
#define FOR(i,bg,ed) for(ll i=(bg);i<(ed);i++)
#define REP(i,n) FOR(i,0,n)

#define MOD 1000000007

const int INF = int(1e9);

using namespace std;

typedef vector<int> V;
typedef vector<V> VV;



// ???????????????1??¨?????????????????§???
// ????????????k*2
// ????????????k*2+1
// ??????floor(k/2)
// ??¨?????????
// ???????????????1??¨????????¨????????°?????????????????????????????°?????§??????????????????????????????????????????
// ?????°?????????????????§????????°???????????§??????????????????

const int N = 1 << 17;  // ???????????°
//const int NIL = INT_MAX;
const ll NIL = 1e18;

ll maxi[N * 2]; // ?????????k?????????????????????????????§???
ll lazy[N * 2]; // lazy[k]????????????k???????????¨??????lazy[k]??§???????????¶?????¨?????????????????¨??????lazy[k]=NIL?????¨???????????????????????¨?´??????????

void setLazy(int k, int v) {
    lazy[k] = v;

    // ??????????????????????????¨?????? v ??§???????????¶????????????????????????????????¶????????????k????????§??????v??§??????
    maxi[k] = v;

    // *** ?????? ***
    // ????????????????????¶?????°???????????¨??§????????£??¨????????????
    // ?????????O(1)????????¢?????§??¨?????§??????????????????????????????????????§???????????§????????°?????¶?????°???????????¨??§????????§?????????
    // ?????¨?????°?????????????????¨?????????????????¶???????????????????????????????????°???????????¨??????????????§????????°???
    //
    // fill v := v ??§???????????¶???
    // add v := v ???????????????
    //
    // ??¨??????????¨???????????????????????????????????????????
    // add u ??????????????? fill v ??????????????¨??? (fill v) . (add u) ??¨???????????¨???????????????
    // ????????¨?????\????????¢????????????????????????
    //
    // (add v) . (add u) = (add v+u)
    // (add v) . (fill u) = (fill v+u)
    // (fill v) . (add u) = (fill v)
    // (fill v) . (fill u) = (fill v)
    //
    // ????????????add u ??¨ fill u ????£????????????? (add or fill, Int) ??§??????????????????
    // ?????£??????????????? add ??§????????? fill ??§???????????¨????????????????????±??¨?????????/???????????¶????????? 2 ???????????±????????£?????¨?????§?????????
    // ?????°??????????????????????????????????????????????????????????????????????????¨???????????¨???????????????????????????????????????
    //
    // ?????¶?????°???????????¨??????????????????????????????????????????????????¨????????????
    // ??????????????¶?????¬?????°???????????¨????????§???????????¨????????????
    // ??????????????????????????????????????±???????????????????????????
    //
    // ????§£??????????????????????????????????????????????????????????????¶???????????¶?????¬????????????????????¨??????????????§????????????
    // ???????????¶???????????????????????????????????°???
    //  (timeS, valueS) . (timeT, valueT) = max((timeS, valueS), (timeT, valueT))
    // ??¨??????????????????????????¢??§?????????
}

void push(int k) {
    // ?????¶?????????????????????????????°???????????????
    if (lazy[k] == NIL) {
        return;
    }
    setLazy(k * 2 + 0, lazy[k]);
    setLazy(k * 2 + 1, lazy[k]);

    // ????????????????????¬??????????????§????????????????????????
    lazy[k] = NIL;
}

void fix(int k) {
    // ?????????k?????????????????????????????§?????????????????????????????§????????¨????????????????????§??????????????§???
    maxi[k] = max(maxi[k * 2], maxi[k * 2 + 1]);
}

// ??????[queryL,queryR)???val??§???????????¶???
void fill(int queryL, int queryR, int val, int k = 1, int nodeL = 0, int nodeR = N) {
    // ?????¨???????????¨????????????????????????????????????????????????????????\?????????????????????????????????
    if (nodeR <= queryL || queryR <= nodeL) {
        return;
    }
    // ???????????????????????¨?????????????????¨??????????????????????????¶????????????????????????????????£?????¨??°???
    if (queryL <= nodeL && nodeR <= queryR) {
        setLazy(k, val);
        return;
    }
    // ???????????????????????¨??????????????????push??????
    push(k);
    int nodeM = (nodeL + nodeR) / 2;
    fill(queryL, queryR, val, k * 2 + 0, nodeL, nodeM);
    fill(queryL, queryR, val, k * 2 + 1, nodeM, nodeR);

    // ???????????????????????¨??????????????±???fix??????
    fix(k);
}

// ??????[queryL, queryR)????????§???????±???????
ll maximum(int queryL, int queryR, int k = 1, int nodeL = 0, int nodeR = N) {
    // ?????¨???????????¨???????????????????????????????????????
    if (nodeR <= queryL || queryR <= nodeL) {
        return -(1e18);
    }
    // ???????????????????????¨?????????????????¨???????????????
    if (queryL <= nodeL && nodeR <= queryR) {
        return maxi[k];
    }
    // ???????????????????????¨??????????????????push??????
    push(k);
    int nodeM = (nodeL + nodeR) / 2;
    ll vl = maximum(queryL, queryR, k * 2 + 0, nodeL, nodeM);
    ll vr = maximum(queryL, queryR, k * 2 + 1, nodeM, nodeR);
    return max(vl, vr);
}


int n, q;
int com, s, t, x;


signed main()
{
    cin >> n >> q;

    for (int i=0; i<N*2; i++) {
        lazy[i] = NIL;
    }

    fill(0, n, INT_MAX);

    REP(i,q) {
        cin >> com;
        if (com == 0) {
            cin >> s >> t >> x;
            fill(s, t + 1, x);
        } else {
            cin >> s;
            cout << maximum(s, s + 1) << endl;
        }
    }

    return 0;
}

Measured memory_bytes: 6680