#define rep(i, n) for(int i = 0; i < (int)(n); i++)
typedef long long ll;
#include <bits/stdc++.h>
using namespace std;
const ll INF = pow(2,33);

template<typename T>
struct SegmentTree{
    vector<T> node;
    ll cou;
    ll size;
    SegmentTree(int n=1, T first_value = 0 ){
        cou = 0;
        while( n > (int)pow(2,cou) ) cou++;
        cou++;
        node.resize((int)pow(2,cou),first_value);
        size = (int)pow(2,cou);
    }
    // void update(int index, T value ){
    //     update_node(convert(index),value);
    // }
    
    void update_range(int s,int t,int k,int l,int r, T value ){
        // std::cout << l<<" "<<r <<" "<<k << std::endl;
        if(r <= s || t <= l ) return;
        if(s <= l && r <= t ) {
            node[k] += value;
            return ;
        }
        update_range(s,t,child1(k),l,(l+r)/2,value);
        update_range(s,t,child1(k)+1,(l+r)/2,r,value);
    }
    
    // void update_node(int node_index, T value ){
    //     // 本人と親を更新
        
    //     // 処理次第
    //     node[node_index] = value;
        
    //     if( node_index == 0 ) return;

    //     update_node(parent(node_index),value);
    // }
    // // [a,b)に対して答える

    // ll query(int a, int b, int k, int l, int r) {
    //     // std::cout << l<<" "<<r << std::endl;
    //     if (r <= a || b <= l){
    //         return 0;
    //     }
    //     if (a <= l && r <= b){
    //         return node[k]; // ノード k の担当範囲がクエリ区間 [a, b) に完全に含まれる
    //     }else {
    //         // 一部だけ範囲が被る場合は左右の子に委託する
    //         ll c1 = query(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子に値を聞く
    //         ll c2 = query(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子に値を聞く
    //         return c1+c2; // 左右の子の値の min を取る
    //     }
    // }
    ll find(int x){
        ll result = 0;
        ll now_node = convert(x);
        while(true){
            result += node[now_node];
            if(now_node == 0) break;
            now_node = parent(now_node);
        }
        return result;
    }

    int parent(int node_index){
        return (node_index-1)/2;
    }
    int convert(int origin){
        return origin    +(int)(pow(2,cou-1)-1);
    }
    int rconvert(int node_index){
        return node_index-(int)(pow(2,cou-1)-1);
    }
    int child1( int node_index){
        return node_index*2+1;
    }
    // TLEうんでるっぽい
    // // 元の配列のindexを返す[l,r)
    // pair<int,int> cover(int node_index){
    //     if(rconvert(node_index)>=0){
    //         return {rconvert(node_index),rconvert(node_index)+1};
    //     }

    //     return {
    //         cover(  child1(node_index) ).first,
    //         cover(  child1(node_index)+1 ).second
    //     };
    // }
    void debug(){
        ll v = 0;
        for (int i = 0; i < cou; i++) {
            for (int j = 0; j < (int)pow(2,i) ; j++) {
                std::cout << node[v].first<<","<<node[v].second<<" ";
                v++;
            }
            std::cout << std::endl;
        }
        std::cout << std::endl;
    }
};

int main(void){
    ll n,q;
    std::cin >> n>>q;
    SegmentTree< ll > seg(n,0);

    for (int i = 0; i < q; i++) {
        int c;
        std::cin >> c;
        
        if(c==0){
            ll s,t,x;
            std::cin >> s>>t>>x;
            s--;
            t--;
            seg.update_range(s,t+1,0,0,seg.size/2,x);
            // seg.debug();
        }else{
            ll x;
            std::cin >> x;
            x--;
            std::cout << seg.find(x) << std::endl;
        }
    }
}



Measured memory_bytes: 5144