// Original C++ solution (slower):
#include <cstdio>

#include <climits>

#include <algorithm>

using namespace std;



// Abstract Lazy Segment Tree (????±?????±?????????¶?????°???????????¨)

const int SIZE = 1 << 17; // 2^17 = 131072

template<typename T>

struct lazysegtree {

    // ?????????????????????

    T node[2*SIZE], lazy[2*SIZE], I;

    bool need_upd[2*SIZE];



    // ????????¬????????§??? (update, query ??? 2 ???????????????)

    // update function ??????????????????????????¢????????????

    // upd_f(X, Y, l, r) -> ????????? [l, r) ??§???????????????????????? X ??? Y ????????????

    // lazy ???????????? update ??¨??????????????? 1 ??????????????¨?????°?????????

    T (*upd_f)(T, T, int, int), (*qry_f)(T, T);



    // ???????????¨?????????????????????????????¨?????? node ??¨ lazy ??????????????§?????????

    lazysegtree(T (*op1)(T, T, int, int), T (*op2)(T, T), T X) {

        upd_f = op1;

        qry_f = op2;

        I = X;

        fill(lazy, lazy+2*SIZE, I);

        fill(node, node+2*SIZE, I);

        fill(need_upd, need_upd+2*SIZE, false);

    }



    void lazy_eval(int k, int l, int r) {

        if(!need_upd[k]) return;

        node[k] = upd_f(node[k], lazy[k], l, r);

        if(r - l > 1) {

            lazy[2*k+1] = upd_f(lazy[2*k+1], lazy[k], 0, 1);

            lazy[2*k+2] = upd_f(lazy[2*k+2], lazy[k], 0, 1);

            need_upd[2*k+1] = need_upd[2*k+2] = true;

        }

        lazy[k] = I;

        need_upd[k] = false;

    }



    // ???????????? [a, b) ??????????????? val ??????????????????

    // (upd_f ?????¨????????????)

    void update(int a, int b, T val, int l=0, int r=SIZE, int k=0) {

        lazy_eval(k, l, r);

        if(b <= l || r <= a) return;

        if(a <= l && r <= b) {

            lazy[k] = upd_f(lazy[k], val, 0, 1);

            need_upd[k] = true;

            lazy_eval(k, l, r);

        }

        else {

            int mid = (l + r) / 2;

            update(a, b, val, l, mid, 2*k+1);

            update(a, b, val, mid, r, 2*k+2);

            node[k] = qry_f(node[2*k+1], node[2*k+2]);

        }

    }



    // ???????????? [a, b) ?????????????????¨???????????????

    // (qry_f ?????¨????????????)

    T query(int a, int b, int l=0, int r=SIZE, int k=0) {

        lazy_eval(k, l, r);

        if(b <= l || r <= a) return I;

        if(a <= l && r <= b) return node[k];

        int mid = (l + r) / 2;

        T vl = query(a, b, l, mid, 2*k+1);

        T vr = query(a, b, mid, r, 2*k+2);

        return qry_f(vl, vr);

    }

};



// [[???????????????]]

// update ??¨??¨ query ??¨?????¢??°??¨????????? (??¢??°????????????????????????????????????????????????) ?????¨???????????£?¨???????

// ??????????????¨???update ??¨?????¢??°??? upd ??§???query ??¨?????¢??°??? fnd ??§??????????????? INT_MAX



int upd(int a, int b, int l, int r) {return a + (r - l) * b;}

int fnd(int a, int b) {return a + b;}

lazysegtree<int> seg(upd, fnd, 0);



int main() {

    int N, Q; scanf("%d%d", &N, &Q);

    while(Q--) {

        int q; scanf("%d", &q);

        if(q == 0) {

            int s, t, x; scanf("%d%d%d", &s, &t, &x); s--;

            seg.update(s, t, x);

        }

        else {

            int i; scanf("%d", &i);

            printf("%d\n", seg.query(i-1, i));

        }

    }

    return 0;

}

// Optimized solution to the same problem (faster):
#include <iostream>

#include <cstdio>

#include <algorithm>

#include <climits>

#include <functional>

using namespace std;



// 動的遅延セグメント木 (必要なところだけノードを作る)



template <typename MonoidType, typename OperatorType>

struct LazySegNode {

    MonoidType value;

    OperatorType lazy_value;

    bool need_update;

    LazySegNode *ch[2];

    

    LazySegNode() {}

    LazySegNode(MonoidType value_, OperatorType lazy_value_) :

        value(value_), lazy_value(lazy_value_) {

        need_update = false;

        ch[0] = ch[1] = nullptr;

    }

};



template <typename MonoidType, typename OperatorType, class SegFunc, typename IdxType = int>

struct DynamicLazySegmentTree {

    // node, identity element

    using LNode = LazySegNode<MonoidType, OperatorType>;

    IdxType n;

    LNode *root;

    MonoidType E0;

    OperatorType E1;



    DynamicLazySegmentTree() {}

    DynamicLazySegmentTree(IdxType n_, MonoidType E0_, OperatorType E1_) :

        E0(E0_), E1(E1_) {

        root = new LNode(E0_, E1_);

        n = 1; while(n < n_) n *= 2;

    }



    void eval(LNode *node, IdxType l, IdxType r) {

        if(!node->need_update) return;

        node->value = SegFunc::update(node->value, SegFunc::accumulate(node->lazy_value, r - l));

        if(r - l > 1) {

            if(!node->ch[0]) node->ch[0] = new LNode(E0, E1);

            if(!node->ch[1]) node->ch[1] = new LNode(E0, E1);

            node->ch[0]->lazy_value = SegFunc::lazy_update(node->ch[0]->lazy_value, node->lazy_value);

            node->ch[1]->lazy_value = SegFunc::lazy_update(node->ch[1]->lazy_value, node->lazy_value);

            node->ch[0]->need_update = node->ch[1]->need_update = true;

        }

        node->lazy_value = E1;

        node->need_update = false;

    }



    void update(LNode *node, IdxType a, IdxType b, OperatorType x,

                IdxType l, IdxType r) {

        eval(node, l, r);

        if(b <= l or r <= a) return;

        if(a <= l and r <= b) {

            node->lazy_value = SegFunc::lazy_update(node->lazy_value, x);

            node->need_update = true;

            eval(node, l, r);

        }

        else {

            IdxType mid = (l + r) / 2;



            MonoidType vl = E0, vr = E0;

            if(!(b <= l or mid <= a)) {

                if(!node->ch[0]) node->ch[0] = new LNode(E0, E1);

                update(node->ch[0], a, b, x, l, mid);

                vl = node->ch[0]->value;

            }

            if(!(b <= mid or r <= a)) {

                if(!node->ch[1]) node->ch[1] = new LNode(E0, E1);

                update(node->ch[1], a, b, x, mid, r);

                vr = node->ch[1]->value;

            }

            node->value = SegFunc::combine(vl, vr);

        }

    }



    MonoidType query(LNode *node, IdxType a, IdxType b, IdxType l, IdxType r) {

        if(b <= l or r <= a) return E0;

        eval(node, l, r);

        if(a <= l and r <= b) return node->value;

        IdxType mid = (l + r) / 2;

        MonoidType vl = (node->ch[0] ? query(node->ch[0], a, b, l, mid) : E0);

        MonoidType vr = (node->ch[1] ? query(node->ch[1], a, b, mid, r) : E0);

        return SegFunc::combine(vl, vr);

    }



    // update [a, b)-th element (applied value: x)

    void update(IdxType a, IdxType b, OperatorType x) {

        update(root, a, b, x, 0, n);

    }



    // range query for [a, b)

    MonoidType query(IdxType a, IdxType b) {

        return query(root, a, b, 0, n);

    }

};





// Verified on Apr 27, 2019

void DSL_2_D() {

    struct SegFunc {

        static int update(int a, int b) { return b; }

        static int combine(int a, int b) { return min(a, b); }

        static int lazy_update(int a, int b) { return b; }

        static int accumulate(int a, int b) { return a; }

    };

    

    int N, Q; cin >> N >> Q;

    DynamicLazySegmentTree<int, int, SegFunc> seg(N, INT_MAX, INT_MAX);

    

    int indexed = 0;

    for(int i=0; i<Q; i++) {

        int query_type; cin >> query_type;

        if(query_type == 0) {

            int s, t, x; cin >> s >> t >> x; t++;

            s -= indexed, t -= indexed;

            seg.update(s, t, x);

        }

        if(query_type == 1) {

            int s; cin >> s;

            s -= indexed;

            cout << seg.query(s, s+1) << endl;

        }

        // seg.dump();

    }

}



// Verified on Apr 27, 2019

void DSL_2_E() {

    struct SegFunc {

        static int update(int a, int b) { return a + b; }

        static int combine(int a, int b) { return a + b; }

        static int lazy_update(int a, int b) { return a + b; }

        static int accumulate(int a, int x) { return a * x; }

    };



    int N, Q; cin >> N >> Q;

    DynamicLazySegmentTree<int, int, SegFunc> seg(N, 0, 0);

    

    int indexed = 1;

    for(int i=0; i<Q; i++) {

        int query_type; cin >> query_type;

        if(query_type == 0) {

            int s, t, x; cin >> s >> t >> x; t++;

            s -= indexed, t -= indexed;

            seg.update(s, t, x);

        }

        if(query_type == 1) {

            int s; cin >> s;

            s -= indexed;

            cout << seg.query(s, s+1) << endl;

        }

        // seg.dump();

    }    

}



// Verified on Apr 27, 2019

void DSL_2_F() {

    struct SegFunc {

        static int update(int a, int b) { return b; }

        static int combine(int a, int b) { return min(a, b); }

        static int lazy_update(int a, int b) { return b; }

        static int accumulate(int a, int x) { return a; }

    };

    

    int N, Q; cin >> N >> Q;

    DynamicLazySegmentTree<int, int, SegFunc> seg(N, INT_MAX, 0);

    

    int indexed = 0;

    for(int i=0; i<Q; i++) {

        int query_type; cin >> query_type;

        if(query_type == 0) {

            int s, t, x; cin >> s >> t >> x; t++;

            s -= indexed, t -= indexed;

            seg.update(s, t, x);

        }

        if(query_type == 1) {

            int s, t; cin >> s >> t; t++;

            s -= indexed; t -= indexed;

            cout << seg.query(s, t) << endl;

        }

        // seg.dump();

    }    

}



// Verified on Apr 27, 2019

void DSL_2_G() {

    using ll = long long int;

    struct SegFunc {

        static ll update(ll a, ll b) { return a + b; }

        static ll combine(ll a, ll b) { return a + b; }

        static ll lazy_update(ll a, ll b) { return a + b; }

        static ll accumulate(ll a, ll x) { return a * x; }

    };



    int N, Q; cin >> N >> Q;

    DynamicLazySegmentTree<ll, ll, SegFunc> seg(N, 0, 0);

    

    int indexed = 1;

    for(int i=0; i<Q; i++) {

        int query_type; cin >> query_type;

        if(query_type == 0) {

            int s, t, x; cin >> s >> t >> x; t++;

            s -= indexed, t -= indexed;

            seg.update(s, t, x);

        }

        if(query_type == 1) {

            int s, t; cin >> s >> t; t++;

            s -= indexed; t -= indexed;

            cout << seg.query(s, t) << endl;

        }

        // seg.dump();

    }    

}



/*

// Verified on May 28, 2019

void DSL_2_H() {

    int N, Q; cin >> N >> Q;

    using ll = long long int;

    using Pair = pair<ll, ll>;

    DynamicLazySegmentTree<ll, Pair> seg(N, INT_MAX, make_pair(0, 0),

                                       [](ll a, Pair b) {

                                             if(b.second == 1) {

                                                 return b.first;

                                             }

                                             else {

                                                 return a + b.first;

                                             }

                                         },  // upd

                                       [](ll a, ll  b) { return min(a, b); },  // cmb

                                       [](Pair a, Pair b) {

                                           if(a.second == 0 and b.second == 0) {

                                               return make_pair(a.first + b.first, 0LL);

                                           }

                                           if(a.second == 0 and b.second == 1) {

                                               return b;

                                           }

                                           if(a.second == 1 and b.second == 0) {

                                               return make_pair(a.first + b.first, 1LL);

                                           }

                                           if(a.second == 1 and b.second == 1) {

                                               return b;

                                           }

                                       },

                                       [](Pair a, int x) { return a;         }); // acc

    

    int indexed = 0;

    for(int i=0; i<N; i++) {

        seg.update(i, i+1, make_pair(0, 1));

    }

    for(int i=0; i<Q; i++) {

        int query_type; cin >> query_type;

        if(query_type == 0) {

            int s, t, x; cin >> s >> t >> x; t++;

            s -= indexed, t -= indexed;

            seg.update(s, t, make_pair(x, 0));

        }

        if(query_type == 1) {

            int s, t; cin >> s >> t; t++;

            s -= indexed; t -= indexed;

            cout << seg.query(s, t) << endl;

        }

        // seg.dump();

    }    

}



// Verified on May 28, 2019

void DSL_2_I() {

    int N, Q; cin >> N >> Q;

    using ll = long long int;

    DynamicLazySegmentTree<ll, ll> seg(N, 0, 0,

                                       [](ll a, ll  b) { return b;     },  // upd

                                       [](ll a, ll  b) { return a + b; },  // cmb

                                       [](ll a, ll  b) { return b;     },  // lzy

                                       [](ll a, int x) { return a * x; }); // acc

    

    int indexed = 0;

    for(int i=0; i<Q; i++) {

        int query_type; cin >> query_type;

        if(query_type == 0) {

            int s, t, x; cin >> s >> t >> x; t++;

            s -= indexed, t -= indexed;

            seg.update(s, t, x);

        }

        if(query_type == 1) {

            int s, t; cin >> s >> t; t++;

            s -= indexed; t -= indexed;

            cout << seg.query(s, t) << endl;

        }

        // seg.dump();

    }    

}



// TLE

void ABC128_E() {

    const int RANGE = 1 << 30;

    int N, Q; cin >> N >> Q;



    DynamicLazySegmentTree<int, int> seg(RANGE, INT_MAX, INT_MAX,

                                         [](int a, int b) { return min(a, b); },

                                         [](int a, int b) { return min(a, b); },

                                         [](int a, int b) { return min(a, b); },

                                         [](int a, int b) { return a; });



    for(int i=0; i<N; i++) {

        int s, t, x; cin >> s >> t >> x;

        s = max(0, s-x), t = max(0, t-x);

        seg.update(s, t, x);

    }

    for(int i=0; i<Q; i++) {

        int x; cin >> x;

        int res = seg.query(x, x+1);

        if(res == INT_MAX) cout << -1 << endl;

        else cout << res << endl;

    }

}

*/



int main() {

    // DSL_2_D();

    DSL_2_E();

    // DSL_2_F();

    // DSL_2_G();

    // DSL_2_H();

    // DSL_2_I();

    // ABC128_E();

    return 0;

}




// Fastest known solution for this problem: