#include <bits/stdc++.h>
using namespace std;

using LL = long long;

struct Oper {
  int op, x, y, z;
  Oper(int op = 0, int x = 0, int y = 0, int z = 0)
      : op(op), x(x), y(y), z(z) {}
};
vector<LL> ans;

constexpr int N = 2E5;
constexpr int Inf = 2E9;

int n, O;
priority_queue<int> val1[N], del1[N];
priority_queue<int, vector<int>, greater<int>> val2[N], del2[N];

int cnt[4 * N + 10], mx[4 * N + 10], mn[4 * N + 10];
LL sum[4 * N + 10];

int pre[N], suf[N];
LL res[N];

void init(int n, int q) {
  ::n = n;
  for (O = 1; O < n + 2; O <<= 1);
  fill(mx, mx + O + n + 2, -Inf);
  fill(mn, mn + O + n + 2, Inf);
  fill(pre, pre + q, -Inf);
  fill(suf, suf + q, Inf);
}

void clr(int p) {
  while (val1[p].size()) val1[p].pop();
  while (val2[p].size()) val2[p].pop();
  while (del1[p].size()) del1[p].pop();
  while (del2[p].size()) del2[p].pop();
  for (int u = O + 1 + p; u; u >>= 1) {
    cnt[u] = sum[u] = 0;
    mx[u] = -Inf, mn[u] = Inf;
  }
}

void appVal(int p, int v, int op) {
  for (int u = O + 1 + p; u; u >>= 1) {
    cnt[u] += op;
    sum[u] += v * op;
  }
}
void appMax(int p, int v, int op) {
  if (op == 1) val1[p].emplace(v);
  else del1[p].emplace(v);
  while (val1[p].size() && del1[p].size() && val1[p].top() == del1[p].top()) {
    val1[p].pop();
    del1[p].pop();
  }
  mx[O + 1 + p] = (val1[p].size() ? val1[p].top() : -Inf);
  for (int u = (O + 1 + p) >> 1; u; u >>= 1) {
    mx[u] = max(mx[u << 1], mx[u << 1 | 1]);
  }
}
void appMin(int p, int v, int op) {
  if (op == 1) val2[p].emplace(v);
  else del2[p].emplace(v);
  while (val2[p].size() && del2[p].size() && val2[p].top() == del2[p].top()) {
    val2[p].pop();
    del2[p].pop();
  }
  mn[O + 1 + p] = (val2[p].size() ? val2[p].top() : Inf);
  for (int u = (O + 1 + p) >> 1; u; u >>= 1) {
    mn[u] = min(mn[u << 1], mn[u << 1 | 1]);
  }
}

int qC, qMx, qMn;
LL qS;

void qry(int l, int r) {
  l = O + l, r = O + r + 2;
  qC = qS = 0, qMx = -Inf, qMn = Inf;
  while (l ^ r ^ 1) {
    if (~l & 1) {
      qC += cnt[l ^ 1];
      qS += sum[l ^ 1];
      qMx = max(qMx, mx[l ^ 1]);
      qMn = min(qMn, mn[l ^ 1]);
    }
    if (r & 1) {
      qC += cnt[r ^ 1];
      qS += sum[r ^ 1];
      qMx = max(qMx, mx[r ^ 1]);
      qMn = min(qMn, mn[r ^ 1]);
    }
    l >>= 1, r >>= 1;
  }
}

vector<int> rag;

void solve(vector<Oper> &oper, int l, int r) {
  if (!oper.size()) return;
  if (l == r) {
    for (auto [op, x, y, z] : oper) {
      if (op >= 100) {
        qry(x, y);
        pre[op - 100] = max(pre[op - 100], qMx);
        suf[op - 100] = min(suf[op - 100], qMn);
        res[op - 100] += qS;
        LL nans = res[op - 100] - LL(qC - z) * rag[l];
        if ((qC - z) % 2 == 0) {
          ans[op - 100] = nans;
        } else {
          ans[op - 100] = nans + min(rag[l] - pre[op - 100], suf[op - 100] - rag[l]);
        }
      } else {
        if (abs(op) == 1) {
          appVal(x, y, op);
          appMax(x, y, op);
        } else {
          appVal(x, y, op);
          appMax(x, 2 * y - z, op / 2);
        }
      }
    }
    for (auto [op, x, y, z] : oper) {
      if (op < 100) {
        clr(x);
      }
    }
    return;
  }
  int mid = (l + r) / 2;
  bool has1 = false, has2 = false;
  vector<Oper> oper1, oper2;
  for (auto [op, x, y, z] : oper) {
    if (op >= 100) {
      qry(x, y);
      if (z <= qC) {
        suf[op - 100] = min(suf[op - 100], qMn);
        oper1.emplace_back(op, x, y, z);
        has1 = true;
      } else {
        pre[op - 100] = max(pre[op - 100], qMx);
        res[op - 100] += qS;
        oper2.emplace_back(op, x, y, z - qC);
        has2 = true;
      }
    } else {
      if (y <= rag[mid]) { // update value and prefix max
        if (abs(op) == 1) {
          appVal(x, y, op);
          appMax(x, y, op);
        } else {
          appVal(x, y, op);
          appMax(x, 2 * y - z, op / 2);
        }
        oper1.emplace_back(op, x, y, z);
      } else { // update suffix min
        if (abs(op) == 1) {
          appMin(x, y, op);
        } else {
          appMin(x, z, op / 2);
        }
        oper2.emplace_back(op, x, y, z);
      }
    }
  }
  for (auto [op, x, y, z] : oper) {
    if (op < 100) {
      clr(x);
    }
  }
  if (has1) solve(oper1, l, mid);
  if (has2) solve(oper2, mid + 1, r);
}

int main() {
  cin.tie(0)->sync_with_stdio(0);
  int n, q;
  cin >> n >> q;
  vector<int> a(n), b(n);
  vector<Oper> oper;
  auto add = [&](int v, int i) {
    if (a[i] <= b[i] - a[i]) {
      oper.emplace_back(v, i, a[i] * 2);
      oper.emplace_back(v, i, (b[i] - a[i]) * 2);
      rag.emplace_back(a[i] * 2);
      rag.emplace_back((b[i] - a[i]) * 2);
    } else {
      oper.emplace_back(v * 2, i, b[i], a[i] * 2);
      rag.emplace_back(b[i]);
    }
  };
  for (int i = 0; i < n; ++i) {
    cin >> a[i] >> b[i];
    add(1, i);
  }
  for (int i = 0; i < q; ++i) {
    int op;
    cin >> op;
    if (op == 1) {
      int p, x, y;
      cin >> p >> x >> y;
      add(-1, p);
      a[p] = x, b[p] = y;
      add(1, p);
    } else {
      int l, r, k;
      cin >> l >> r >> k; // 0 <= l, r < n
      oper.emplace_back(100 + i, l, r, k);
    }
  }
  sort(rag.begin(), rag.end());
  rag.erase(unique(rag.begin(), rag.end()), rag.end());
  ans.assign(q, -1);
  init(n, q);
  solve(oper, 0, int(rag.size()) - 1);
  for (int i = 0; i < q; ++i) {
    if (~ans[i]) {
      cout << ans[i] / 2 << "\n";
    }
  }
  fprintf(stderr, "TIME: %.2f\n", double(clock()) / CLOCKS_PER_SEC);
  return 0;
}