#include <bits/stdc++.h>
#define pb emplace_back
#define fst first
#define scd second
#define mkp make_pair
#define uint unsigned
#define mems(a, x) memset((a), (x), sizeof(a))

using namespace std;
typedef long long ll;
typedef double db;
typedef unsigned long long ull;
typedef long double ldb;
typedef pair<ll, ll> pii;

namespace IO {
	const int maxn = 1 << 20;
	
    char ibuf[maxn], *iS, *iT, obuf[maxn], *oS = obuf;

	inline char gc() {
		return (iS == iT ? iT = (iS = ibuf) + fread(ibuf, 1, maxn, stdin), (iS == iT ? EOF : *iS++) : *iS++);
	}

	template<typename T = int>
	inline T read() {
		char c = gc();
		T x = 0;
		bool f = 0;
		while (c < '0' || c > '9') {
			f |= (c == '-');
			c = gc();
		}
		while (c >= '0' && c <= '9') {
			x = (x << 1) + (x << 3) + (c ^ 48);
			c = gc();
		}
		return f ? ~(x - 1) : x;
	}

	inline void flush() {
		fwrite(obuf, 1, oS - obuf, stdout);
		oS = obuf;
	}
	
	struct Flusher {
		~Flusher() {
			flush();
		}
	} AutoFlush;

	inline void pc(char ch) {
		if (oS == obuf + maxn) {
			flush();
		}
		*oS++ = ch;
	}

	template<typename T>
	inline void write(T x) {
		static char stk[64], *tp = stk;
		if (x < 0) {
			x = ~(x - 1);
			pc('-');
		}
		do {
			*tp++ = x % 10;
			x /= 10;
		} while (x);
		while (tp != stk) {
			pc((*--tp) | 48);
		}
	}
	
	template<typename T>
	inline void writesp(T x) {
		write(x);
		pc(' ');
	}
	
	template<typename T>
	inline void writeln(T x) {
		write(x);
		pc('\n');
	}
}

using IO::read;
using IO::write;
using IO::pc;
using IO::writesp;
using IO::writeln;

const int maxn = 400100;
const ll inf = 0x3f3f3f3f3f3f3f3fLL;

ll n, m, nt, N;
pii c[maxn];
bool vis[maxn];

struct item {
	ll x, o, i, y;
	item(ll a = 0, ll b = 0, ll c = 0, ll d = 0) : x(a), o(b), i(c), y(d) {}
} a[maxn];

inline bool operator < (const item &a, const item &b) {
	if (a.x * b.o != b.x * a.o) {
		return a.x * b.o < b.x * a.o;
	} else {
		return a.i < b.i;
	}
}

struct node {
	ll a, b, x, y;
} b[maxn];

struct que {
	ll o, x, y, z, xx, yy, mx1, mx2, mn, cnt, sum, ans;
} qq[maxn];

inline int ID(item x) {
	// printf("ID %lld %lld %lld %lld %lld\n", x.x, x.o, x.i, x.y, (ll)(lower_bound(a + 1, a + nt + 1, x) - a));
	return lower_bound(a + 1, a + nt + 1, x) - a;
}

struct event {
	int o, i, x;
	event(int a = 0, int b = 0, int c = 0) : o(a), i(b), x(c) {}
};

struct BIT {
	ll a[maxn], b[maxn];
	
	inline void update(ll x, ll y, ll z) {
		for (int i = x; i <= n; i += (i & (-i))) {
			a[i] += y;
			b[i] += z;
		}
	}
	
	inline void clear(ll x) {
		for (int i = x; i <= n; i += (i & (-i))) {
			a[i] = b[i] = 0;
		}
	}
	
	inline pii query(ll x) {
		ll s1 = 0, s2 = 0;
		for (int i = x; i; i -= (i & (-i))) {
			s1 += a[i];
			s2 += b[i];
		}
		return mkp(s1, s2);
	}
	
	inline pii query(ll l, ll r) {
		pii p = query(l - 1), q = query(r);
		return mkp(q.fst - p.fst, q.scd - p.scd);
	}
} T1;

struct Heap {
	vector<ll> a;
	
	inline void clear() {
		a.clear();
	}
	
	inline void insert(ll x) {
		// printf("insert %lld\n", x);
		a.insert(lower_bound(a.begin(), a.end(), x), x);
	}
	
	inline void erase(ll x) {
		// printf("erase %lld\n", x);
		assert(find(a.begin(), a.end(), x) != a.end());
		a.erase(lower_bound(a.begin(), a.end(), x));
	}
	
	inline ll qmx() {
		return a.size() ? a.back() : -inf;
	}
	
	inline ll qmn() {
		return a.size() ? a[0] : inf;
	}
} S1[maxn >> 2], S2[maxn >> 2], S3[maxn >> 2];

struct wwh {
	ll mx1, mx2;
	wwh(ll a = 0, ll b = 0) : mx1(a), mx2(b) {}
};

inline wwh operator + (const wwh &a, const wwh &b) {
	return wwh(max(a.mx1, b.mx1), max(a.mx2, b.mx2));
}

struct SGT1 {
	wwh a[maxn];
	
	inline void init() {
		for (int i = 0; i < maxn; ++i) {
			a[i] = wwh(-inf, -inf);
		}
	}
	
	inline void update(int x, wwh y) {
		x += N;
		a[x] = y;
		x >>= 1;
		while (x) {
			a[x] = a[x << 1] + a[x << 1 | 1];
			x >>= 1;
		}
	}
	
	inline void query(int l, int r, wwh &x) {
		for (l += N - 1, r += N + 1; l ^ r ^ 1; l >>= 1, r >>= 1) {
			if (!(l & 1)) {
				x = x + a[l ^ 1];
			}
			if (r & 1) {
				x = x + a[r ^ 1];
			}
		}
	}
} T2;

struct SGT2 {
	ll a[maxn];
	
	inline void init() {
		mems(a, 0x3f);
	}
	
	inline void update(int x, ll y) {
		x += N;
		a[x] = y;
		x >>= 1;
		while (x) {
			a[x] = min(a[x << 1], a[x << 1 | 1]);
			x >>= 1;
		}
	}
	
	inline ll query(int l, int r) {
		ll res = inf;
		for (l += N - 1, r += N + 1; l ^ r ^ 1; l >>= 1, r >>= 1) {
			if (!(l & 1)) {
				res = min(res, a[l ^ 1]);
			}
			if (r & 1) {
				res = min(res, a[r ^ 1]);
			}
		}
		return res;
	}
} T3;

void dfs(int l, int r, vector<event> Q) {
	if (Q.empty()) {
		return;
	}
	// printf("%d %d %d\n", l, r, (int)Q.size());
	if (l == r) {
		for (event e : Q) {
			int o = e.o, i = e.i, x = e.x;
			if (o == 1) {
				T1.update(x, a[i].o, a[i].x);
				if (a[i].o == 1) {
					S2[x].insert(a[i].x);
				} else {
					S1[x].insert(a[i].x);
					S2[x].insert(a[i].x - a[i].y);
				}
				T2.update(x, wwh(S1[x].qmx(), S2[x].qmx()));
			} else if (o == -1) {
				T1.update(x, -a[i].o, -a[i].x);
				if (a[i].o == 1) {
					S2[x].erase(a[i].x);
				} else {
					S1[x].erase(a[i].x);
					S2[x].erase(a[i].x - a[i].y);
				}
				T2.update(x, wwh(S1[x].qmx(), S2[x].qmx()));
			} else {
				pii p = T1.query(qq[i].x, qq[i].y);
				wwh t(-inf, -inf);
				T2.query(qq[i].x, qq[i].y, t);
				qq[i].mx1 = max(qq[i].mx1, t.mx1);
				qq[i].mx2 = max(qq[i].mx2, t.mx2);
				qq[i].cnt += p.fst;
				qq[i].sum += p.scd;
				// if (i == 1) {
					// printf("%lld %lld\n", qq[i].cnt, qq[i].sum);
				// }
				if (qq[i].cnt == qq[i].z) {
					qq[i].ans = qq[i].sum;
				} else {
					qq[i].ans = qq[i].sum + min(qq[i].mn - qq[i].mx1, -qq[i].mx2);
				}
			}
		}
		for (event e : Q) {
			int o = e.o, x = e.x;
			if (o == 1) {
				T1.clear(x);
				S1[x].clear();
				S2[x].clear();
				T2.update(x, wwh(-inf, -inf));
			}
		}
		return;
	}
	// printf("l, r: %d %d\n", l, r);
	int mid = (l + r) >> 1;
	vector<event> L, R;
	for (event e : Q) {
		int o = e.o, i = e.i, x = e.x;
		if (o == 1) {
			if (i <= mid) {
				// printf("update %d %lld %lld\n", x, a[i].o, a[i].x);
				T1.update(x, a[i].o, a[i].x);
				L.pb(e);
			} else {
				R.pb(e);
			}
		} else if (o == -1) {
			if (i <= mid) {
				T1.update(x, -a[i].o, -a[i].x);
				L.pb(e);
			} else {
				R.pb(e);
			}
		} else {
			pii p = T1.query(qq[i].x, qq[i].y);
			// if (i == 1) {
				// printf("%lld %lld %lld %lld\n", p.fst, p.scd, qq[i].cnt, qq[i].sum);
			// }
			if (p.fst >= qq[i].z - qq[i].cnt) {
				vis[i] = 1;
				L.pb(e);
			} else {
				qq[i].cnt += p.fst;
				qq[i].sum += p.scd;
				vis[i] = 0;
				R.pb(e);
			}
		}
	}
	for (event e : Q) {
		int o = e.o, i = e.i, x = e.x;
		// printf("o: %d, i: %d, x: %d\n", o, i, x);
		if (o == 1) {
			if (i <= mid) {
				T1.clear(x);
				if (a[i].o == 1) {
					S2[x].insert(a[i].x);
				} else {
					S1[x].insert(a[i].x);
					S2[x].insert(a[i].x - a[i].y);
				}
				T2.update(x, wwh(S1[x].qmx(), S2[x].qmx()));
			} else {
				if (a[i].o == 1) {
					S3[x].insert(a[i].x);
				} else {
					S3[x].insert(a[i].y);
				}
				T3.update(x, S3[x].qmn());
			}
		} else if (o == -1) {
			if (i <= mid) {
				if (a[i].o == 1) {
					// printf("x: %lld\n", a[i].x);
					S2[x].erase(a[i].x);
				} else {
					// printf("i: %d\n", i);
					// printf("x, y: %lld %lld\n", a[i].x, a[i].y);
					S1[x].erase(a[i].x);
					S2[x].erase(a[i].x - a[i].y);
				}
				T2.update(x, wwh(S1[x].qmx(), S2[x].qmx()));
			} else {
				if (a[i].o == 1) {
					S3[x].erase(a[i].x);
				} else {
					S3[x].erase(a[i].y);
				}
				T3.update(x, S3[x].qmn());
			}
		} else if (vis[i]) {
			// puts("here1");
			qq[i].mn = min(qq[i].mn, T3.query(qq[i].x, qq[i].y));
		} else {
			// puts("here2");
			wwh t(-inf, -inf);
			T2.query(qq[i].x, qq[i].y, t);
			qq[i].mx1 = max(qq[i].mx1, t.mx1);
			qq[i].mx2 = max(qq[i].mx2, t.mx2);
		}
	}
	for (event e : Q) {
		int o = e.o, i = e.i, x = e.x;
		if (o == 1) {
			if (i <= mid) {
				S1[x].clear();
				S2[x].clear();
				T2.update(x, wwh(-inf, -inf));
			} else {
				S3[x].clear();
				T3.update(x, inf);
			}
		}
	}
	dfs(l, mid, L);
	dfs(mid + 1, r, R);
}

void solve() {
	n = read();
	m = read();
	N = 1;
	while (N < n + 2) {
		N <<= 1;
	}
	for (int i = 1; i <= n; ++i) {
		b[i].a = read();
		b[i].b = read();
		if (b[i].a * 2 <= b[i].b) {
			b[i].x = ++nt;
			a[nt] = item(b[i].a, 1, nt);
			b[i].y = ++nt;
			a[nt] = item(b[i].b - b[i].a, 1, nt);
		} else {
			b[i].x = ++nt;
			a[nt] = item(b[i].b, 2, nt, b[i].a);
		}
	}
	for (int i = 1; i <= m; ++i) {
		qq[i].o = read();
		qq[i].x = read();
		qq[i].y = read();
		qq[i].z = read();
		if (qq[i].o == 1) {
			++qq[i].x;
			if (qq[i].y * 2 <= qq[i].z) {
				qq[i].xx = ++nt;
				a[nt] = item(qq[i].y, 1, nt);
				qq[i].yy = ++nt;
				a[nt] = item(qq[i].z - qq[i].y, 1, nt);
			} else {
				qq[i].xx = ++nt;
				a[nt] = item(qq[i].z, 2, nt, qq[i].y);
			}
		} else {
			++qq[i].x;
			++qq[i].y;
			qq[i].mx1 = qq[i].mx2 = -inf;
			qq[i].mn = inf;
		}
	}
	sort(a + 1, a + nt + 1);
	vector<event> Q;
	for (int i = 1; i <= n; ++i) {
		if (b[i].a * 2 <= b[i].b) {
			b[i].x = ID(item(b[i].a, 1, b[i].x));
			b[i].y = ID(item(b[i].b - b[i].a, 1, b[i].y));
			c[i] = mkp(b[i].x, b[i].y);
			Q.pb(1, b[i].x, i);
			Q.pb(1, b[i].y, i);
		} else {
			b[i].x = ID(item(b[i].b, 2, b[i].x, b[i].a));
			c[i] = mkp(b[i].x, 0);
			Q.pb(1, b[i].x, i);
		}
	}
	for (int i = 1; i <= m; ++i) {
		if (qq[i].o == 1) {
			Q.pb(-1, c[qq[i].x].fst, qq[i].x);
			if (c[qq[i].x].scd) {
				Q.pb(-1, c[qq[i].x].scd, qq[i].x);
			}
			if (qq[i].y * 2 <= qq[i].z) {
				qq[i].xx = ID(item(qq[i].y, 1, qq[i].xx));
				qq[i].yy = ID(item(qq[i].z - qq[i].y, 1, qq[i].yy));
				Q.pb(1, qq[i].xx, qq[i].x);
				Q.pb(1, qq[i].yy, qq[i].x);
				c[qq[i].x] = mkp(qq[i].xx, qq[i].yy);
			} else {
				qq[i].xx = ID(item(qq[i].z, 2, qq[i].xx, qq[i].y));
				Q.pb(1, qq[i].xx, qq[i].x);
				c[qq[i].x] = mkp(qq[i].xx, 0);
			}
		} else {
			Q.pb(0, i, 0);
		}
	}
	T2.init();
	T3.init();
	dfs(1, nt, Q);
	for (int i = 1; i <= m; ++i) {
		if (qq[i].o == 2) {
			writeln(qq[i].ans);
		}
	}
}

int main() {
	int T = 1;
	// scanf("%d", &T);
	while (T--) {
		solve();
	}
	return 0;
}