import std.algorithm;
import std.array;
import std.conv;
import std.math;
import std.range;
import std.stdio;
import std.string;
import std.typecons;

int readint() {
    return readln.chomp.to!int;
}

int[] readints() {
    return readln.split.map!(to!int).array;
}

void main() {
    _lazy[] = NIL;
    _maxi[] = int.max;

    auto nq = readints();
    int n = nq[0], q = nq[1];
    for (int i = 0; i < q; i++) {
        auto xs = readints();

        if (xs[0] == 0) {
            int s = xs[1];
            int t = xs[2];
            int x = xs[3];
            fill(s, t + 1, x);
        }
        else {
            int s = xs[1];
            int v = maximum(s, s + 1);
            writeln(v);
        }
    }
}

///////////////////////////////////////

const int N = 1 << 18; // ???????????°
const int NIL = int.max;

int[N * 2] _maxi; // ?????????k?????????????????????????????§???
int[N * 2] _lazy; // lazy[k]????????????k???????????¨??????lazy[k]??§???????????¶?????¨?????????????????¨??????lazy[k]=NIL?????¨???????????????????????¨?´??????????

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

    // ??????????????????????????¨?????? v ??§???????????¶????????????????????????????????¶????????????k????????§??????v??§??????
    _maxi[k] = v;
}

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)????????§???????±???????
int maximum(int queryL, int queryR, int k = 1, int nodeL = 0, int nodeR = N) {
    // ?????¨???????????¨???????????????????????????????????????
    if (nodeR <= queryL || queryR <= nodeL) {
        return int.min;
    }
    // ???????????????????????¨?????????????????¨???????????????
    if (queryL <= nodeL && nodeR <= queryR) {
        return _maxi[k];
    }
    // ???????????????????????¨??????????????????push??????
    push(k);
    int nodeM = (nodeL + nodeR) / 2;
    int vl = maximum(queryL, queryR, k * 2 + 0, nodeL, nodeM);
    int vr = maximum(queryL, queryR, k * 2 + 1, nodeM, nodeR);
    return max(vl, vr);
}