#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
using i128 = __int128;
using u128 = unsigned __int128;
template <typename T>
void chkmax(T &x, const T &y) {
  if (x < y) x = y;
}
template <typename T>
void chkmin(T &x, const T &y) {
  if (y < x) x = y;
}
namespace io {
char ibuf[1 << 22], *ihd = ibuf, *itl = ibuf;
char getchar() {
  if (ihd == itl) {
    ihd = ibuf;
    itl = ibuf + fread(ibuf, 1, 1 << 22, stdin);
  }
  return ihd == itl ? EOF : *(ihd++);
}
char obuf[1 << 22], *otl = obuf;
void putchar(char ch) {
  if (otl == obuf + (1 << 22)) {
    fwrite(obuf, 1, 1 << 22, stdout);
    otl = obuf;
  }
  *(otl++) = ch;
}
void flush() { fwrite(obuf, 1, otl - obuf, stdout); }
}  // namespace io
template <typename T>
void read(T &x) {
  x = 0;
  bool f = false;
  char ch = io::getchar();
  for (; !isdigit(ch); ch = io::getchar()) f ^= (ch == '-');
  for (; isdigit(ch); ch = io::getchar()) x = x * 10 + ch - '0';
  if (f) x = -x;
}
template <typename T>
void write(T x) {
  if (x < 0) {
    io::putchar('-');
    x = -x;
  }
  static char stk[40], *tp = stk;
  do {
    *(tp++) = x % 10 + '0';
    x /= 10;
  } while (x);
  while (tp != stk) io::putchar(*(--tp));
}
struct operation {
  int t, l, r, v;
};
struct query {
  int l, r, id;
};
constexpr int MAXN = 5e5 + 10, MAXBN = 715;
int n, m, q, bs, bn, st[MAXBN], ed[MAXBN], bel[MAXN];
int val[MAXN], tag[MAXBN];
ll ans[MAXN];
vector<pair<int, ll>> buc[MAXN];
query qry[MAXN];
operation op[MAXN];
namespace blk1 {
constexpr int MAXBN = 710;
int bs, bn, st[MAXBN], ed[MAXBN], bel[MAXN];
ll val[MAXN], sum[MAXBN];
void init() {
  bs = round(sqrt(m));
  bn = (m + bs - 1) / bs;
  for (int i = 1; i <= bn; ++i) {
    st[i] = ed[i - 1] + 1;
    ed[i] = min(st[i] + bs - 1, m);
    fill(bel + st[i], bel + ed[i] + 1, i);
  }
}
void update(int p, ll x) {
  val[p] += x;
  sum[bel[p]] += x;
}
ll query(int p) {
  return accumulate(val + p, val + ed[bel[p]] + 1,
                    accumulate(sum + bel[p] + 1, sum + bn + 1, 0ll));
}
}  // namespace blk1
void push_tag(int b) {
  if (tag[b]) {
    fill(val + st[b], val + ed[b] + 1, tag[b]);
    tag[b] = 0;
  }
}
namespace blk2 {
constexpr int MAXBN = 710;
int bs, bn, st[MAXBN], ed[MAXBN], bel[MAXN];
ll suf[MAXN], bsuf[MAXBN];
void init() {
  bs = round(sqrt(m));
  bn = (m + bs - 1) / bs;
  for (int i = 1; i <= bn; ++i) {
    st[i] = ed[i - 1] + 1;
    ed[i] = min(st[i] + bs - 1, m);
    fill(bel + st[i], bel + ed[i] + 1, i);
  }
}
void clear() {
  fill(suf + 1, suf + m + 1, 0);
  fill(bsuf + 1, bsuf + bn + 1, 0);
}
void update(int p, ll x) {
  for (int i = st[bel[p]]; i <= p; ++i) suf[i] += x;
  for (int i = 1; i < bel[p]; ++i) bsuf[i] += x;
}
ll query(int p) { return suf[p] + bsuf[bel[p]]; }
}  // namespace blk2
void solve(int b) {
  blk2::clear();
  int num = 0, bl = st[b], br = ed[b], cov = 0;
  fill(val + bl, val + br + 1, 0);
  for (int i = 1, ptr = 1; i <= m; ++i) {
    int l = op[i].l, r = op[i].r;
    if (op[i].t == 1) {
      if (l < bl && r > br) {
        if (!cov) {
          for (int x = bl, y; x <= br; x = y) {
            y = x + 1;
            while (y <= br && val[y] == val[x]) ++y;
            if (val[x]) {
              blk2::update(val[x], (ll)-op[val[x]].v * (y - x));
              buc[i].emplace_back(val[x], (ll)op[val[x]].v * num * (y - x));
            }
          }
        }
        cov = i;
      } else if (l <= br && r >= bl) {
        chkmax(l, bl);
        chkmin(r, br);
        if (cov) {
          fill(val + bl, val + br + 1, cov);
          blk2::update(cov, (ll)op[cov].v * (br - bl + 1));
          buc[i].emplace_back(cov, (ll)-op[cov].v * num * (br - bl + 1));
          cov = 0;
        }
        for (int x = l, y; x <= r; x = y) {
          y = x + 1;
          while (y <= r && val[y] == val[x]) ++y;
          if (val[x]) {
            blk2::update(val[x], (ll)-op[val[x]].v * (y - x));
            buc[i].emplace_back(val[x], (ll)op[val[x]].v * num * (y - x));
          }
        }
        fill(val + l, val + r + 1, i);
        blk2::update(i, (ll)op[i].v * (r - l + 1));
        buc[i].emplace_back(i, (ll)-op[i].v * num * (r - l + 1));
      }
    } else {
      num += (l < bl && r > br);
    }
    for (; ptr <= q && qry[ptr].r == i; ++ptr)
      ans[qry[ptr].id] += blk2::query(qry[ptr].l) * num;
  }
}
int main() {
  // freopen("mfsn.in", "r", stdin);
  // freopen("mfsn.out", "w", stdout);
  read(n);
  read(m);
  read(q);
  for (int i = 1; i <= m; ++i) {
    read(op[i].t);
    read(op[i].l);
    read(op[i].r);
    if (op[i].t == 1) read(op[i].v);
  }
  for (int i = 1; i <= q; ++i) {
    read(qry[i].l);
    read(qry[i].r);
    qry[i].id = i;
  }
  sort(qry + 1, qry + q + 1,
       [](const query &x, const query &y) { return x.r < y.r; });
  bs = max(round(sqrt(n) * 4), 1.0);
  bn = (n + bs - 1) / bs;
  for (int i = 1; i <= bn; ++i) {
    st[i] = ed[i - 1] + 1;
    ed[i] = min(st[i] + bs - 1, n);
    fill(bel + st[i], bel + ed[i] + 1, i);
  }
  blk2::init();
  for (int i = 1; i <= bn; ++i) solve(i);
  blk1::init();
  auto small_query = [](int l, int r) {
    if (tag[bel[l]]) {
      blk1::update(tag[bel[l]], op[tag[bel[l]]].v * (r - l + 1ll));
    } else {
      for (int i = l; i <= r; ++i)
        if (val[i]) blk1::update(val[i], op[val[i]].v);
    }
  };
  for (int i = 1, ptr = 1; i <= m; ++i) {
    int l = op[i].l, r = op[i].r;
    if (op[i].t == 1) {
      if (bel[l] == bel[r]) {
        push_tag(bel[l]);
        fill(val + l, val + r + 1, i);
      } else {
        push_tag(bel[l]);
        fill(val + l, val + ed[bel[l]] + 1, i);
        fill(tag + bel[l] + 1, tag + bel[r], i);
        push_tag(bel[r]);
        fill(val + st[bel[r]], val + r + 1, i);
      }
    } else {
      if (bel[l] == bel[r]) {
        small_query(l, r);
      } else {
        small_query(l, ed[bel[l]]);
        small_query(st[bel[r]], r);
        for (int j = bel[l] + 1; j < bel[r]; ++j) {
          if (tag[j])
            blk1::update(tag[j], op[tag[j]].v * (ed[j] - st[j] + 1ll));
        }
      }
    }
    for (auto &j : buc[i]) blk1::update(j.first, j.second);
    for (; ptr <= q && qry[ptr].r == i; ++ptr)
      ans[qry[ptr].id] += blk1::query(qry[ptr].l);
  }
  for (int i = 1; i <= q; ++i) {
    write(ans[i]);
    io::putchar('\n');
  }
  io::flush();
  return 0;
}
/*
g++ mfsn.cpp -o mfsn -std=c++14 -O2 -Wall -Wextra -Wshadow -g
-fsanitize=address,undefined
*/