//#define NDEBUG
#include "bits/stdc++.h"
#include <iostream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <array>
#include <random>
#ifdef _MSC_VER
#include <ppl.h>
//#include <boost/multiprecision/cpp_dec_float.hpp>
//#include <boost/multiprecision/cpp_int.hpp>
//#include <boost/rational.hpp>
//#include <opencv2/core.hpp>
//#include <opencv2/imgproc.hpp>
//#include <opencv2/highgui.hpp>
//#else
//#include <omp.h>
#endif


using namespace std;

#define DUMPOUT cerr
#define dump(...) DUMPOUT<<"  ";DUMPOUT<<#__VA_ARGS__<<" :["<<__LINE__<<":"<<__FUNCTION__<<"]"<<endl;DUMPOUT<<"    ";dump_func(__VA_ARGS__)

using uint = unsigned; using ll = long long; using ull = unsigned long long; using pii = pair<int, int>; using pll = pair<ll, ll>; using pdd = pair<double, double>; using pss = pair<string, string>;
template <typename _KTy, typename _Ty> ostream& operator << (ostream& o, const pair<_KTy, _Ty>& m) { o << "{" << m.first << ", " << m.second << "}"; return o; }
template <typename _KTy, typename _Ty> ostream& operator << (ostream& o, const map<_KTy, _Ty>& m) { if (m.empty()) { o << "{ }"; return o; } o << "{" << *m.begin(); for (auto itr = ++m.begin(); itr != m.end(); itr++) { o << ", " << *itr; } o << "}"; return o; }
template <typename _KTy, typename _Ty> ostream& operator << (ostream& o, const unordered_map<_KTy, _Ty>& m) { if (m.empty()) { o << "{ }"; return o; } o << "{" << *m.begin(); for (auto itr = ++m.begin(); itr != m.end(); itr++) { o << ", " << *itr; } o << "}"; return o; }
template <typename _Ty> ostream& operator << (ostream& o, const vector<_Ty>& v) { if (v.empty()) { o << "{ }"; return o; } o << "{" << v.front(); for (auto itr = ++v.begin(); itr != v.end(); itr++) { o << ", " << *itr; } o << "}"; return o; }
template <typename _Ty> ostream& operator << (ostream& o, const deque<_Ty>& v) { if (v.empty()) { o << "{ }"; return o; } o << "{" << v.front(); for (auto itr = ++v.begin(); itr != v.end(); itr++) { o << ", " << *itr; } o << "}"; return o; }
template <typename _Ty> ostream& operator << (ostream& o, const set<_Ty>& s) { if (s.empty()) { o << "{ }"; return o; } o << "{" << *(s.begin()); for (auto itr = ++s.begin(); itr != s.end(); itr++) { o << ", " << *itr; } o << "}"; return o; }
template <typename _Ty> ostream& operator << (ostream& o, const unordered_set<_Ty>& s) { if (s.empty()) { o << "{ }"; return o; } o << "{" << *(s.begin()); for (auto itr = ++s.begin(); itr != s.end(); itr++) { o << ", " << *itr; }	o << "}"; return o; }
template <typename _Ty> ostream& operator << (ostream& o, const stack<_Ty>& s) { if (s.empty()) { o << "{ }"; return o; } stack<_Ty> t(s); o << "{" << t.top(); t.pop(); while (!t.empty()) { o << ", " << t.top(); t.pop(); } o << "}";	return o; }
template <typename _Ty> ostream& operator << (ostream& o, const list<_Ty>& l) { if (l.empty()) { o << "{ }"; return o; } o << "{" << l.front(); for (auto itr = ++l.begin(); itr != l.end(); ++itr) { o << ", " << *itr; } o << "}"; return o; }
template <typename _KTy, typename _Ty> istream& operator >> (istream& is, pair<_KTy, _Ty>& m) { is >> m.first >> m.second; return is; }
template <typename _Ty> istream& operator >> (istream& is, vector<_Ty>& v) { for (size_t t = 0; t < v.size(); t++) is >> v[t]; return is; }
template <typename _Ty> istream& operator >> (istream& is, deque<_Ty>& v) { for (size_t t = 0; t < v.size(); t++) is >> v[t]; return is; }
namespace aux { // print tuple
  template<typename Ty, unsigned N, unsigned L> struct tp { static void print(ostream& os, const Ty& v) { os << get<N>(v) << ", "; tp<Ty, N + 1, L>::print(os, v); } };
  template<typename Ty, unsigned N> struct tp<Ty, N, N> { static void print(ostream& os, const Ty& v) { os << get<N>(v); } };
}

template<typename... Tys> ostream& operator<<(ostream& os, const tuple<Tys...>& t) { os << "{"; aux::tp<tuple<Tys...>, 0, sizeof...(Tys) - 1>::print(os, t); os << "}"; return os; }

template<typename A, size_t N, typename T> inline void Fill(A(&array)[N], const T& val) { fill((T*)array, (T*)(array + N), val); }

template <typename ... Args>
std::string format(const std::string& fmt, Args ... args) {
  size_t len = std::snprintf(nullptr, 0, fmt.c_str(), args ...);
  std::vector<char> buf(len + 1);
  std::snprintf(&buf[0], len + 1, fmt.c_str(), args ...);
  return std::string(&buf[0], &buf[0] + len);
}

void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail> void dump_func(Head&& head, Tail&&... tail) { DUMPOUT << head; if (sizeof...(Tail) == 0) { DUMPOUT << " "; } else { DUMPOUT << ", "; } dump_func(move(tail)...); }

#define PI 3.14159265358979323846
#define EPS 1e-8
#define rep(t,n) for(int t=0;t<(n);++t)
#define ALL(j) (j).begin(), (j).end()
#define SZ(j) ((int)(j).size())
#define fake false

class Timer {
public:
  double t = 0;
  Timer() {}
  static double time() {
#ifdef _MSC_VER
    return __rdtsc() / 2.8e9;
#else
    unsigned long long a, d;
    __asm__ volatile("rdtsc"
      : "=a"(a), "=d"(d));
    return (d << 32 | a) / 2.8e9;
#endif
  }
  void measure() { t = time() - t; }
  double elapsedMs() { return (time() - t) * 1000.0; }
} timer;

struct Xorshift {
  uint64_t x = 88172645463325252LL;
  unsigned next_int() {
    x = x ^ (x << 7);
    return x = x ^ (x >> 9);
  }
  unsigned next_int(unsigned mod) {
    x = x ^ (x << 7);
    x = x ^ (x >> 9);
    return x % mod;
  }
  unsigned next_int(unsigned l, unsigned r) {
    x = x ^ (x << 7);
    x = x ^ (x >> 9);
    return x % (r - l + 1) + l;
  }
  double next_double() {
    return double(next_int()) / UINT_MAX;
  }
} rnd;

template<typename T>
void shuffle_vector(vector<T>& v, Xorshift& rnd) {
  int n = v.size();
  for (int i = n - 1; i >= 1; i--) {
    int r = rnd.next_int(i);
    swap(v[i], v[r]);
  }
}





template<typename OperatorMonoid>
class DualSegmentTree {
  using H = OperatorMonoid(*)(OperatorMonoid, OperatorMonoid);
  int n, sz, height;
  vector<OperatorMonoid> lazy;
  const H h;
  const OperatorMonoid om;
public:
  DualSegmentTree(int n, const H h, const OperatorMonoid om) : n(n), sz(1), height(0), h(h), om(om) {
    while (sz <= n) sz <<= 1, height++;
    lazy.resize(2 * sz, om);
  }
  inline void propagate(int k) {
    if (lazy[k] != om) {
      lazy[2 * k + 0] = h(lazy[2 * k + 0], lazy[k]);
      lazy[2 * k + 1] = h(lazy[2 * k + 1], lazy[k]);
      lazy[k] = om;
    }
  }
  inline void thrust(int k) {
    for (int i = height; i > 0; i--) propagate(k >> i);
  }
  void update(int a, int b, const OperatorMonoid& x) {
    thrust(a += sz);
    thrust(b += sz - 1);
    for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
      if (l & 1) lazy[l] = h(lazy[l], x), ++l;
      if (r & 1) --r, lazy[r] = h(lazy[r], x);
    }
  }
  OperatorMonoid operator[](int k) {
    thrust(k += sz);
    return lazy[k];
  }
};

//template<typename Monoid, typename OperatorMonoid = Monoid>
//struct LazySegmentTree {
//  using F = Monoid(*)(Monoid, Monoid);
//  using G = Monoid(*)(Monoid, OperatorMonoid);
//  using H = OperatorMonoid(*)(OperatorMonoid, OperatorMonoid);
//
//  int sz, height;
//  vector<Monoid> data;
//  vector<OperatorMonoid> lazy;
//  const F f;
//  const G g;
//  const H h;
//  const Monoid M1;
//  const OperatorMonoid OM0;
//
//  LazySegmentTree(int n, const F f, const G g, const H h, const Monoid& M1, const OperatorMonoid OM0)
//    : f(f), g(g), h(h), M1(M1), OM0(OM0) {
//    sz = 1;
//    height = 0;
//    while (sz <= n) sz <<= 1, height++;
//    data.assign(2 * sz, M1);
//    lazy.assign(2 * sz, OM0);
//  }
//  void set(int k, const Monoid& x) {
//    data[k + sz] = x;
//  }
//  void build() {
//    for (int k = sz - 1; k > 0; k--) {
//      data[k] = f(data[2 * k + 0], data[2 * k + 1]);
//    }
//  }
//  inline void propagate(int k) {
//    if (lazy[k] != OM0) {
//      lazy[2 * k + 0] = h(lazy[2 * k + 0], lazy[k]);
//      lazy[2 * k + 1] = h(lazy[2 * k + 1], lazy[k]);
//      data[k] = reflect(k);
//      lazy[k] = OM0;
//    }
//  }
//  inline Monoid reflect(int k) {
//    return lazy[k] == OM0 ? data[k] : g(data[k], lazy[k]);
//  }
//  inline void recalc(int k) {
//    while (k >>= 1) data[k] = f(reflect(2 * k + 0), reflect(2 * k + 1));
//  }
//  inline void thrust(int k) {
//    for (int i = height; i > 0; i--) propagate(k >> i);
//  }
//  void update(int a, int b, const OperatorMonoid& x) {
//    thrust(a += sz);
//    thrust(b += sz - 1);
//    for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
//      if (l & 1) lazy[l] = h(lazy[l], x), ++l;
//      if (r & 1) --r, lazy[r] = h(lazy[r], x);
//    }
//    recalc(a);
//    recalc(b);
//  }
//  Monoid query(int a, int b) {
//    thrust(a += sz);
//    thrust(b += sz - 1);
//    Monoid L = M1, R = M1;
//    for (int l = a, r = b + 1; l < r; l >>= 1, r >>= 1) {
//      if (l & 1) L = f(L, reflect(l++));
//      if (r & 1) R = f(reflect(--r), R);
//    }
//    return f(L, R);
//  }
//  Monoid operator[](const int& k) {
//    return query(k, k + 1);
//  }
//  template< typename C >
//  int find_subtree(int a, const C& check, Monoid& M, bool type) {
//    while (a < sz) {
//      propagate(a);
//      Monoid nxt = type ? f(reflect(2 * a + type), M) : f(M, reflect(2 * a + type));
//      if (check(nxt)) a = 2 * a + type;
//      else M = nxt, a = 2 * a + 1 - type;
//    }
//    return a - sz;
//  }
//  template< typename C >
//  int find_first(int a, const C& check) {
//    Monoid L = M1;
//    if (a <= 0) {
//      if (check(f(L, reflect(1)))) return find_subtree(1, check, L, false);
//      return -1;
//    }
//    thrust(a + sz);
//    int b = sz;
//    for (a += sz, b += sz; a < b; a >>= 1, b >>= 1) {
//      if (a & 1) {
//        Monoid nxt = f(L, reflect(a));
//        if (check(nxt)) return find_subtree(a, check, L, false);
//        L = nxt;
//        ++a;
//      }
//    }
//    return -1;
//  }
//  template< typename C >
//  int find_last(int b, const C& check) {
//    Monoid R = M1;
//    if (b >= sz) {
//      if (check(f(reflect(1), R))) return find_subtree(1, check, R, true);
//      return -1;
//    }
//    thrust(b + sz - 1);
//    int a = sz;
//    for (b += sz; a < b; a >>= 1, b >>= 1) {
//      if (b & 1) {
//        Monoid nxt = f(reflect(--b), R);
//        if (check(nxt)) return find_subtree(b, check, R, true);
//        R = nxt;
//      }
//    }
//    return -1;
//  }
//};

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);

  int n, q;
  cin >> n >> q;
  auto g = [](int a, int b) { return a + b; };
  DualSegmentTree<int> seg(n, g, 0);
  rep(_, q) {
    int t, x, y, z;
    cin >> t;
    switch (t) {
    case 0:
      cin >> x >> y >> z;
      seg.update(x, y + 1, z);
      break;
    case 1:
      cin >> x;
      cout << seg[x] << '\n';
      break;
    }
  }

  return 0;
}



Measured memory_bytes: 3860