Problem:
Range Update Query (RUQ)

Write a program which manipulates a sequence A = {a0, a1, . . . , an−1} with the following operations:

update(s, t, x): change as, as+1, ..., at to x.

find(i): output the value of ai.

Note that the initial values of ai (i = 0, 1, . . . , n−1) are 231-1.

Input

n q
query1
query2
:
queryq

In the first line, n (the number of elements in A) and q (the number of queries) are given. Then, ith query queryi is given in the following format:

0 s t x

or

1 i

The first digit represents the type of the query. '0' denotes update(s, t, x) and '1' denotes find(i).

Output

For each find operation, print the value.

Constraints

1 ≤ n ≤ 100000

1 ≤ q ≤ 100000

0 ≤ s ≤ t < n

0 ≤ i < n

0 ≤ x < 231−1

Sample Input 1

3 5
0 0 1 1
0 1 2 3
0 2 2 2
1 0
1 1

Sample Output 1

1
3

Sample Input 2

1 3
1 0
0 0 0 5
1 0

Sample Output 2

2147483647
5

Solution in C++14 (judge verdict: Accepted)

//
// Created by Hideaki Imamura on 2020-03-08.
//
# include <bits/stdc++.h>

using namespace std;
typedef long long ll;
typedef pair <ll, ll> l_l;
typedef pair<int, int> i_i;

template<class T>
inline bool chmax(T &a, T b) {
    if (a < b) {
        a = b;
        return true;
    }
    return false;
}

template<class T>
inline bool chmin(T &a, T b) {
    if (a > b) {
        a = b;
        return true;
    }
    return false;
}

# define EPS (1e-7)
# define INF (INT_MAX)
# define PI (acos(-1))
//const ll mod = 1000000007;

template<class T>
void print_vec(vector <T> v) {
    for (auto x : v) {
        cout << x << " ";
    }
    cout << endl;
}

#ifndef ALGORITHMS_DATASTRUCTURE_LAZYSEGMENTTREE_H
#define ALGORITHMS_DATASTRUCTURE_LAZYSEGMENTTREE_H

// T0: 元の配列のモノイド
// T1: T0に対する作用素モノイド
template <class T0, class T1, class F0, class F1, class G, class P> class LazySegmentTree {
    // k番目のノードにのlazyを伝搬
    void eval(int k, int len) {
        // 定数倍高速化
        if (lazy[k] == u1) return;
        // len個分のlazy[k]を評価
        node[k] = g(node[k], p(lazy[k], len));
        if (k < N - 1) {
            // 最下段でなければ下のlazyに伝搬
            lazy[2 * k + 1] = f1(lazy[2 * k + 1], lazy[k]);
            lazy[2 * k + 2] = f1(lazy[2 * k + 2], lazy[k]);
        }
        lazy[k] = u1;
    }
    // k番目のノード[l, r)について、[a, b)の範囲内にxを作用
    void update(int a, int b, T1 x, int k, int l, int r) {
        eval(k, r - l);
        if (b <= l || r <= a) return;
        if (a <= l && r <= b) {
            lazy[k] = f1(lazy[k], x);
            eval(k, r - l);
        } else {
            update(a, b, x, 2 * k + 1, l, (l + r) / 2);
            update(a, b, x, 2 * k + 2, (l + r) / 2, r);
            node[k] = f0(node[2 * k + 1], node[2 * k + 2]);
        }
    }
    // k番目のノード[l, r)について、[a, b)のクエリを求める
    T0 query(int a, int b, int k, int l, int r) {
        if (r <= a || b <= l) return u0;
        eval(k, r - l);
        if (a <= l && r <= b) return node[k];
        T0 vl = query(a, b, 2 * k + 1, l, (l + r) / 2);
        T0 vr = query(a, b, 2 * k + 2, (l + r) / 2, r);
        return f0(vl, vr);
    }

public:
    int sz;  // 元の配列のサイズ
    int N;
    vector<T0> node;
    vector<T1> lazy;
    // T0上の演算、単位元
    const F0 f0;
    const T0 u0;
    // T1上の演算、単位元
    const F1 f1;
    const T1 u1;
    // T0に対するT1の作用
    const G g;
    // 多数のt1(T1)に対するf1の合成
    const P p;

    LazySegmentTree(F0 f0, T0 u0, F1 f1, T1 u1, G g, P p) : f0(f0), u0(u0), f1(f1), u1(u1), g(g), p(p) {}
    void set_by_vector(const vector<T0>& a) {
        sz = a.size();
        for (N = 1; N < sz; N *= 2)
            ;
        node.resize(2 * N - 1, u0);
        lazy.resize(2 * N - 1, u1);
        for (int i = 0; i < sz; i++) node[N - 1 + i] = a[i];
        for (int i = N - 2; i >= 0; i--) node[i] = f0(node[2 * i + 1], node[2 * i + 2]);
    }
    void set_by_unit(int n) {
        sz = n;
        for (N = 1; N < sz; N *= 2)
            ;
        node.resize(2 * N - 1, u0);
        lazy.resize(2 * N - 1, u1);
    }
    // [a, b)にxを作用
    void update(int a, int b, T1 x) {
        assert(0 <= a && a < b && b <= sz);
        update(a, b, x, 0, 0, N);
    }
    void update(int a, T1 x) { update(a, a + 1, x); }
    // [a, b)
    T0 query(int a, int b) { return query(a, b, 0, 0, N); }
    T0 query(int a) { return query(a, a + 1); }
    friend string to_string(LazySegmentTree<T0, T1, F0, F1, G, P>& seg) {
        for (int i = 0; i < seg.sz; i++) seg.query(i);
        return to_string(vector<T0>(seg.node.begin() + (seg.N - 1), seg.node.begin() + (seg.N - 1 + seg.sz)));
    }
};
template <class T0, class T1, class F0, class F1, class G, class P>
auto make_lazy_segment_tree(F0 f0, T0 u0, F1 f1, T1 u1, G g, P p) {
    return LazySegmentTree<T0, T1, F0, F1, G, P>(f0, u0, f1, u1, g, p);
}
// Max && Add
// constexpr Int INF = 1e18;
// auto seg = make_lazy_segment_tree<Int, Int>(
//     [](Int x, Int y) { return max(x, y); }, -INF, [](Int x, Int y) { return x + y; }, 0,
//     [](Int x, Int y) { return x == -INF ? x : x + y; }, [](Int x, int len) { return x; });

#endif //ALGORITHMS_DATASTRUCTURE_LAZYSEGMENTTREE_H

// DSL_2_A
//
//int N, Q;
//
//int main() {
//    cin >> N >> Q;
//    const ll u0 = INF;
//    const ll u1 = -INF;
//    auto seg = make_lazy_segment_tree<ll, ll> (
//            [](ll x, ll y) { return min(x, y); }, u0,
//            [](ll x, ll y) { return y == u1 ? x : y; }, u1,
//            [](ll x, ll y) { return y == u1 ? x : y; },
//            [](ll x, int len) { return x; });
//    seg.set_by_unit(N);
//    for (int q= 0; q < Q; ++q) {
//        ll com, x, y;
//        cin >> com >> x >> y;
//        if (com == 0) {
//            seg.update(x, y);
//        } else {
//            cout << seg.query(x, y + 1) << endl;
//        }
//    }
//    return 0;
//}

// DSL_2_B
//
//int N, Q;
//
//int main() {
//    cin >> N >> Q;
//    const ll u0 = 0;
//    const ll u1 = 0;
//    auto seg = make_lazy_segment_tree<ll, ll> (
//            [](ll x, ll y) { return x + y; }, u0,
//            [](ll x, ll y) { return x + y; }, u1,
//            [](ll x, ll y) { return x + y; },
//            [](ll x, int len) { return x * len; });
//    seg.set_by_unit(N);
//    for (int q= 0; q < Q; ++q) {
//        ll com, x, y;
//        cin >> com >> x >> y;
//        if (com == 0) {
//            x--;
//            seg.update(x, y);
//        } else {
//            x--;
//            y--;
//            cout << seg.query(x, y + 1) << endl;
//        }
//    }
//    return 0;
//}

// DSL_2_D
//
int N, Q;

int main() {
    cin >> N >> Q;
    const ll u0 = INF;
    const ll u1 = -INF;
    auto seg = make_lazy_segment_tree<ll, ll> (
            [](ll x, ll y) { return y == u0 ? x : y; }, u0,
            [](ll x, ll y) { return y == u1 ? x : y; }, u1,
            [](ll x, ll y) { return y == u1 ? x : y; },
            [](ll x, int len) { return x; });
    seg.set_by_unit(N);
    for (int q= 0; q < Q; ++q) {
        ll query;
        cin >> query;
        if (query == 0) {
            ll s, t, x;
            cin >> s >> t >> x;
            seg.update(s, t + 1, x);
        } else {
            ll i;
            cin >> i;
            cout << seg.query(i, i + 1) << endl;
        }
    }
    return 0;
}

// DSL_2_F
//
//int N, Q;
//
//int main() {
//    cin >> N >> Q;
//    static constexpr ll u0 = INF;
//    static constexpr ll u1 = - INF;
//    auto seg = make_lazy_segment_tree<ll, ll> (
//            [](ll x, ll y) { return min(x, y); }, u0,
//            [](ll x, ll y) { return y == u1 ? x : y; }, u1,
//            [](ll x, ll y) { return y == u1 ? x : y; },
//            [](ll x, int len) { return x; });
//    seg.set_by_vector(vector<ll>(N, INF));
//    for (int i = 0; i < Q; ++i) {
//        int q;
//        cin >> q;
//        if (q == 0) {
//            ll s, t, x;
//            cin >> s >> t >> x;
//            seg.update(s, t + 1, x);
//        } else {
//            int s, t;
//            cin >> s >> t;
//            cout << seg.query(s, t + 1) << endl;
//        }
//    }
//    return 0;
//}

// DSL_2_G
//
//int N, Q;
//
//signed main() {
//    cin >> N >> Q;
//    auto seg = make_lazy_segment_tree<ll, ll>(
//            [](ll x, ll y) { return x + y; }, 0,
//            [](ll x, ll y) { return x + y; }, 0,
//            [](ll x, ll y) { return x + y; },
//            [](ll x, int len) { return x * len; });
//    seg.set_by_unit(N);
//    for (ll i = 0; i < Q; ++i) {
//        int q;
//        cin >> q;
//        if (q == 0) {
//            int s, t, x;
//            cin >> s >> t >> x;
//            seg.update(s - 1, t, x);
//        } else {
//            int s, t;
//            cin >> s >> t;
//            cout << seg.query(s - 1, t) << endl;
//        }
//    }
//    return 0;
//}