#include <bits/stdc++.h>

using namespace std;
using ll = long long;

constexpr int inf = 1e9 + 7;

void massert(bool f) {
    while (!f) {
        cout << "mda" << endl;
    }
}

struct SegmentTree {
    vector<pair<int, int>> t;
    vector<ll> ansL;

    int sz = 1, N;

    int cost(int x, int d, ll &ans) {
        massert(x < sz * 2);
        if (t[x].first == -inf) {
            return d;
        }
        if (t[x].first <= t[x].second) {
            ans += max(0, d - t[x].second);
            return min(t[x].second, max(d, t[x].first));
        } else if (t[x << 1].second == -inf) {
            ans += ansL[x];
            cost(x << 1, d, ans);
            return t[x].first;
        } else {
            ans += max(0, d - t[x << 1].second);
            return cost(x << 1 | 1, min(t[x << 1].second, max(d, t[x << 1].first)), ans);
        }
    }

    void pull(int x) {
        massert(x < sz * 2);
        ansL[x] = 0;
        if (t[x << 1 | 1].first == -inf) {
            t[x] = t[x << 1];
            return;
        }
        if (t[x << 1].second == -inf) {
            t[x].first = cost(x << 1 | 1, t[x << 1].first, ansL[x]);
            t[x].second = -inf;
        } else if (t[x << 1 | 1].second == -inf) {
            t[x] = t[x << 1 | 1];
        } else {
            assert(t[x << 1].first <= t[x << 1].second);
            assert(t[x << 1 | 1].first <= t[x << 1 | 1].second);
            if (t[x << 1].first > t[x << 1 | 1].second) {
                t[x].first = t[x << 1 | 1].second;
                t[x].second = -inf;
            } else if (t[x << 1].second < t[x << 1 | 1].first) {
                t[x].first = t[x << 1].first;
                t[x].second = -inf;
            } else {
                t[x].first = max(t[x << 1].first, t[x << 1 | 1].first);
                t[x].second = min(t[x << 1].second, t[x << 1 | 1].second);
                massert(t[x].first <= t[x].second);
            }
        }
    }

    void init(int n, vector<int> L, vector<int> R) {
        sz = 1 << __lg(n) + !!(n & (n - 1));
        N = n;
        t.assign(sz << 1, {-inf, -inf}), ansL.resize(sz << 1);
        for (int i = 0; i < n; ++i) {
            t[i + sz].first = L[i], t[i + sz].second = R[i];
        }
        for (int i = sz - 1; i > 0; --i) {
            pull(i);
        }
    }

    void rangeQuery(int l, int r, int &d, ll &ans, int x, int lx, int rx) {
        if (l >= rx || lx >= r) {
            return;
        }
        if (l <= lx && rx <= r) {
            d = cost(x, d, ans);
            return;
        }
        int mid = lx + rx >> 1;
        rangeQuery(l, r, d, ans, x << 1, lx, mid);
        rangeQuery(l, r, d, ans, x << 1 | 1, mid, rx);
    }

    ll rangeQuery(int l, int r, int &d) {
        assert(l >= 0 && l < N && l < r && r <= N);
        ll ans = 0;
        rangeQuery(l, r, d, ans, 1, 0, sz);
        return ans;
    }

    void modify(int x, int L, int R) {
        x += sz;
        t[x].first = L, t[x].second = R;
        while (x >>= 1) {
            pull(x);
        }
    }
};

//don't forget to add diff between d and needed time

bool stress = true;

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

    int n, q;
    cin >> n >> q;

    vector<int> L(n), R(n), AL(n), AR(n), BL(n), BR(n);

    for (int i = 0; i < n - 1; ++i) {
        cin >> L[i] >> R[i];
        AL[i] = L[i] - i;
        AR[i] = R[i] - i - 1;
        BL[n - i - 2] = L[i] - (n - i - 2);
        BR[n - i - 2] = R[i] - (n - i - 2) - 1;
    }

    SegmentTree A, B;
    if (n > 1) {
        A.init(n - 1, AL, AR);
        B.init(n - 1, BL, BR);
    }

    auto modify = [&](int i, int lx, int rx) {
        L[i] = lx, R[i] = rx;
        AL[i] = L[i] - i;
        AR[i] = R[i] - i - 1;
        BL[n - i - 2] = L[i] - (n - i - 2);
        BR[n - i - 2] = R[i] - (n - i - 2) - 1;
        A.modify(i, AL[i], AR[i]);
        B.modify(n - i - 2, BL[n - i - 2], BR[n - i - 2]);
    };

    auto stupid = [&n](int x, int y, int a, int b, vector<int> &L, vector<int> &R) {
        ll ans = 0;
        for (int i = x; i < y; ++i) {
            ans += max(0, a - R[i]);
            a = min(R[i], max(a, L[i]));
        }
        ans += max(0, a - b);
        return ans;
    };

    auto query = [&](int x, int a, int y, int b) -> ll {
        if (x == y) {
            return max(0, a - b);
        }

        ll ans = 0;
        ll stup = 0;
        bool mda = false;

        if (x <= y) {
            a -= x;
            b -= y;
            stress = false;
            mda = true;
            if (stress) {
                stup = stupid(x, y, a, b, AL, AR);
            }
            ans = A.rangeQuery(x, y, a);
        } else {
            a -= n - x - 1;
            b -= n - y - 1;
            if (stress) {
                stup = stupid(n - x - 1, n - y - 1, a, b, BL, BR);
            }
            ans = B.rangeQuery(n - x - 1, n - y - 1, a);
        }


        ans += max(0, a - b);

        if (stress) {
            if (stup != ans) {
                cout << "should have: " << stup << endl;
                cout << "instead you got: " << ans << endl;
                return 0;
            }
        }

        if (mda) {
            stress = true;
        }

        return ans;
    };

    while (q--) {
        int t;
        cin >> t;

        if (t == 1) {
            int p, s, e;
            cin >> p >> s >> e;
            modify(p - 1, s, e);
        } else {
            int a, b, c, d;
            cin >> a >> b >> c >> d;
            cout << query(a - 1, b, c - 1, d) << '\n';
        }
    }

    return 0;
}