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

#define rep(i, b, e) for (int i = (b); i <= (e); i++)
#define per(i, b, e) for (int i = (e); i >= (b); i--)
#define FOR(i, b, e) rep(i, b, (e)-1)
#define SZ(x) int(x.size())
#define all(x) x.begin(), x.end()
#define pb push_back
#define mp make_pair
#define st first
#define nd second
using ll = long long;
using vi = vector<int>;
using pii = pair<int, int>;

auto& operator<<(auto& o, pair<auto, auto> p) {
  return o << "(" << p.st << ", " << p.nd << ")";
}
auto operator<<(auto& o, auto x) -> decltype(end(x), o) {
  o << "{";
  int i = 0;
  for (auto e : x)
    o << ", " + 2 * !i++ << e;
  return o << "}";
}
#ifdef LOCAL
#define deb(x...)                       \
  cerr << "[" #x "]: ", [](auto... $) { \
    ((cerr << $ << "; "), ...) << endl; \
  }(x)
#else
#define deb(...)
#endif

struct PersistentTree {
  using T = int;
  struct Node {
    int ch[2] = {-1, -1};
    T sum;
    Node() : sum(0) {}  // s t a r t / neutral
    Node(T val) : sum(val) {}
    void pull(Node& l, Node& r) { sum = l.sum + r.sum; }
  };
  vector<Node> t;
  int max_n;
  PersistentTree(vector<int> vals, int _max_n) {
    max_n = _max_n;
    t.resize(SZ(vals));
    // we skip vals[0]

    // cerr << "Tworze drzewo " << max_n << "\n";
    for (int i = 1; i < SZ(vals); i++) {
      // cerr << "Dodaje 1 w " << vals[i] << "\n";
      t[i] = t[i - 1];
      int l = 0, r = max_n;
      int v = i;
      while (l <= r) {
        // cerr << "Jestem w " << l << " " << r << "\n";
        t[v].sum += 1;
        if (l == r)
          break;

        int mid = (l + r) / 2;

        if (vals[i] <= mid) {
          // cerr << "Ide w lewo\n";
          t[v].ch[0] = copy(t[v].ch[0]);
          r = mid;
          v = t[v].ch[0];
        } else {
          // cerr << "Ide w prawo\n";
          t[v].ch[1] = copy(t[v].ch[1]);
          l = mid + 1;
          v = t[v].ch[1];
        }
      }
    }
  }

  int copy(int v) {
    // if v == -1 create a new node
    t.pb(~v ? t[v] : Node());
    return SZ(t) - 1;
  }

  int query(int v, int l) {

    // cerr << "Pytaja ile jest dni przed dniem " << v
    //      << " ktore dochodza do drzew z przedzialu " << l << " " << max_n
    //      << "\n";
    return query(v, l, max_n, 0, max_n);
  }

  int query(int v, int l, int r, int le, int re) {
    deb(v, l, r, le, re);
    if (v == -1)
      return 0;

    if (le > r || re < l) {
      return 0;
    }
    if (l <= le && re <= r) {
      return t[v].sum;
    }

    int mid = (le + re) / 2;
    return query(t[v].ch[0], l, r, le, mid) +
           query(t[v].ch[1], l, r, mid + 1, re);
  }

  void dump() {
#ifdef LOCAL
    for (int i = 0; i < SZ(t); i++) {
      deb(i, t[i].ch[0], t[i].ch[1], t[i].sum);
    }
#endif
  }
};

struct FT {
  vector<ll> s;
  FT(int n) : s(n) {}
  void update(int pos, ll dif) {  // a [ pos ] += d i f
    for (; pos < SZ(s); pos |= pos + 1)
      s[pos] += dif;
  }
  ll query(int pos) {  // sum of values in [0 , pos)
    ll res = 0;
    for (; pos > 0; pos &= pos - 1)
      res += s[pos - 1];
    return res;
  }
  int lower_bound(ll sum) {  // min pos st sum of [0 , pos ] >= sum
    // Returns n if no sum is >= sum, or −1 i f empty sum is .
    if (sum <= 0)
      return -1;
    int pos = 0;
    for (int pw = 1 << 20; pw; pw >>= 1) {
      if (pos + pw <= SZ(s) && s[pos + pw - 1] < sum)
        pos += pw, sum -= s[pos - 1];
    }
    return pos;
  }
};

struct FT2 {
  vector<vi> ys;
  vector<FT> ft;
  FT2(int limx) : ys(limx) {}
  void fakeUpdate(int x, int y) {
    for (; x < SZ(ys); x |= x + 1)
      ys[x].pb(y);
  }
  void init() {
    for (vi& v : ys)
      sort(all(v)), ft.emplace_back(SZ(v));
  }
  int ind(int x, int y) {
    return int(lower_bound(all(ys[x]), y) - ys[x].begin());
  }
  void update(int x, int y, ll dif) {
    for (; x < SZ(ys); x |= x + 1)
      ft[x].update(ind(x, y), dif);
  }
  ll query(int x, int y) {
    x += 1;
    y += 1;
    ll sum = 0;
    for (; x; x &= x - 1)
      sum += ft[x - 1].query(ind(x - 1, y));
    return sum;
  }
};

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

  int n, m, z;
  cin >> n >> m >> z;
  vi a(n + 1);

  int mks = 0;
  for (int i = 1; i <= n; i++) {
    cin >> a[i];
    mks = max(a[i], mks);
  }
  mks = max(n + 1, mks);
  FT2 ft(n + 1);
  PersistentTree per_tree(a, mks);
  // per_tree.dump();

  // const int K = sqrtl(log2(n) * (long double)n * m / z);
  const int K = sqrtl(40 * (long double)n * m / z);
  cerr << n << " " << m << " " << z << " " << mks << "\n";
  cerr << "Wybralem " << K << "\n";
  // const ll K = 0;
  vector<pair<pii, int>> q;

  for (int _ = 0; _ < m + z; _++) {
    int t, p, d;
    cin >> t >> p >> d;
    q.push_back({{t, p}, d});
  }

  vector<pii> fenwick_updates;
  vector<pii> zalegle;
  for (int j = 0; j < SZ(q); j++) {
    int t = q[j].first.first;
    int p = q[j].first.second;
    int w = q[j].second;

    if (t == 1) {
      zalegle.push_back({p, w});
    }

    if (SZ(zalegle) > K) {
      sort(zalegle.rbegin(), zalegle.rend());
      ll sum = 0;
      int i = 0;
      int dzien = n;
      while (dzien > 0) {
        ll dla_tego = 0;
        int idx = i;
        while (idx < SZ(zalegle) && dzien == zalegle[idx].first) {
          dla_tego += zalegle[idx].second;
          idx++;
        }
        sum += dla_tego;

        fenwick_updates.push_back({dzien, sum});
        i = idx;
        dzien--;
      }
      zalegle.clear();
    }
  }
  zalegle.clear();

  for (auto [p, _] : fenwick_updates) {
    // cerr << "Update " << p << " " << mks - a[p] + 1 << " (bo " << a[p] << ")\n";
    ft.fakeUpdate(p, mks - a[p] + 1);
  }

  ft.init();

  for (int j = 0; j < SZ(q); j++) {
    int t = q[j].first.first;
    int p = q[j].first.second;
    deb(q[j], zalegle);

    if (t == 1) {
      int w = q[j].second;
      zalegle.push_back({p, w});

      if (SZ(zalegle) > K) {
        sort(zalegle.rbegin(), zalegle.rend());
        ll sum = 0;
        int i = 0;
        int dzien = n;
        while (dzien > 0) {
          ll dla_tego = 0;
          int idx = i;
          while (idx < SZ(zalegle) && dzien == zalegle[idx].first) {
            dla_tego += zalegle[idx].second;
            idx++;
          }
          sum += dla_tego;

          ft.update(dzien, mks - a[dzien] + 1, sum);
          i = idx;
          dzien--;
        }
        zalegle.clear();
      }
    } else {
      int d = q[j].second;
      ll ans = ft.query(p, mks - d + 1);
      for (auto [pp, ww] : zalegle) {
        int ile = per_tree.query(min(pp, p), d);
        ans += (ll)ile * ww;
      }
      cout << ans << "\n";
    }
  }
}