#include <iostream>
#include <iomanip>
#include <vector>
#include <string>
#include <map>
#include <algorithm>
#include <cmath>
#include <queue>
#include <set>
#include <bitset>
#include <climits>
#include <string.h>
#include <stdlib.h>
#include <time.h>
 
using namespace std;

typedef long long ll;
typedef long double ld;

#define pb(a) push_back(a)

int N = 1e5 + 1;
int mod = 998244353;
const ll inf = LLONG_MAX;

int mult(int a, int b)
{
	return a * 1LL * b % mod;
}

int sum(int a, int b)
{
	return ((a % mod) + (b % mod)) % mod;
}

int mus(int a, int b)
{
	return (((a % mod) - (b % mod)) + mod) % mod;
}

int binpow(int a, int n)
{
	if (n == 0)
		return 1;
	if (n % 2 == 1)
		return binpow(a, n - 1) * 1LL * a % mod;
	else
	{
		int b = binpow(a, n / 2);
		return b * 1LL * b % mod;
	}
}

ll gcd(ll a, ll b)
{
	if (a == 0)
		return b;
	if (b == 0)
		return a;
	if (a > b)
		return gcd(a % b, b);
	return gcd(a, b % a);
}

struct segtreex{
	int NO_OP = -1;

	struct node{
		int set;
		int mx;
	};

	vector<node> t;
	int size;
	void init(int n){
		size = 1;
		while(size < n){
			size *= 2;
		}
		t.assign(2 * size - 1, {NO_OP, 0});
		for(int i = size - 1; i < 2 * size - 1; i++){
			t[i].set = 0;
		}
	}

	void push(int x){
		if(t[x].set == NO_OP)
			return;
		t[2 * x + 1].mx = t[x].set;
		t[2 * x + 2].mx = t[x].set;
		t[2 * x + 1].set = t[x].set;
		t[2 * x + 2].set = t[x].set;
		t[x].set = NO_OP;
	}

	void modify(int l, int r, int v, int x, int lx, int rx){
		if(l >= rx || lx >= r)
			return;
		if(l <= lx && rx <= r){
			t[x].set = v;
			t[x].mx = v;
			return;
		}
		push(x);
		int m = (lx + rx) / 2;
		modify(l, r, v, 2 * x + 1, lx, m);
		modify(l, r, v, 2 * x + 2, m, rx);
		t[x].mx = max(t[2 * x + 1].mx, t[2 * x + 2].mx);
	}

	void modify(int l, int r, int v){
		modify(l, r, v, 0, 0, size);
	}

	int getmax(int l, int r, int x, int lx, int rx){
		if(l >= rx || r <= lx)
			return -1;
		if(l <= lx && rx <= r){
			return t[x].mx;
		}
		push(x);
		int m = (lx + rx) / 2;
		int mxl = getmax(l, r, 2 * x + 1, lx, m);
		int mxr = getmax(l, r, 2 * x + 2, m, rx);
		return max(mxl, mxr);
	}

	int getmax(int l, int r){
		return getmax(l, r, 0, 0, size);
	}
};

struct segtreey{
	unordered_map<ll, ll> t;
	ll size;

	void init(ll n){
		size = 1;
		while(size < n)
			size *= 2;
	}

	void add(ll l, ll r, ll x, ll lx, ll rx, ll v){
		if(l >= rx || lx >= r){
			return;
		}
		if(l <= lx && rx <= r){
			t[x] += v;
			return;
		}
		ll m = (lx + rx) / 2;
		add(l, r, 2 * x + 1, lx, m, v);
		add(l, r, 2 * x + 2, m, rx, v);
	}

	void add(ll l, ll r, ll v){
		add(l, r, 0, 0, size, v);
	}
	
	ll gety(ll i, ll x, ll lx, ll rx){
		if(lx + 1 == rx){
			return t[x];
		}
		ll m = (lx + rx) / 2;
		if(i < m)
			return gety(i, 2 * x + 1, lx, m) + t[x];
		else
			return gety(i, 2 * x + 2, m, rx) + t[x];
	}

	ll gety(ll i){
		return gety(i, 0, 0, size);
	}
};

int main()
{
	ios_base::sync_with_stdio(false);
	cin.tie(0);
	int n, q;
	cin >> n >> q;
	segtreex tx;
	segtreey ty;
	tx.init(n);
	ty.init(1e11);
	while(q--){
		int t;
		cin >> t;
		if(t == 1){
			int l, r, h;
			cin >> l >> r >> h;
			int top = tx.getmax(l - 1, r);
			tx.modify(l - 1, r, top + h);
			ty.add(top + 1, top + h + 1, r - l + 1);
		}else{
			int y;
			cin >> y;
			cout << ty.gety(y) << '\n';
		}
	}
}