#pragma GCC optimize("O3")
#include "bits/stdc++.h"
using namespace std;
#define rep(i,a,b) for(int i=(a); i<(b); ++i)
#define all(x) x.begin(),x.end()
#define sz(x) int(x.size())
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<vi> vvi;

template <class ForwardIt, class T, class Compare>
constexpr ForwardIt sb_lower_bound(
      ForwardIt first, ForwardIt last, const T& value, Compare comp) {
   auto length = last - first;
   while (length > 0) {
      auto rem = length % 2;
      length /= 2;
      if (comp(first[length], value)) {
         first += length + rem;
      }
   }
   return first;
}

namespace smallB{
    const int N = 1e6+500;
    const int B = 900; // nsqrt(n)

    struct wholeblock{
        int positions[B];
        int ord[B], invord[B];
        int num = 0;

        ll sum = 0; // when we update whole block
        void insert(int x){
            positions[num] = x;
            ord[num] = num;
            ++num;
        }
        void build(){
            rep(i,0,num+1) fen[i] = 0;
            sort(ord,ord+num,[&](int i, int j){
                return positions[i] < positions[j];
            });
            rep(i,0,num) invord[ord[i]] = i;
            vi rp(num);
            rep(i,0,num) rp[i] = positions[ord[i]];
            rep(i,0,num) positions[i] = rp[i];
        }

        ll fen[B+1];

        // range update
        void update(int i, ll w){
            int id = num - invord[i%B];
            for(id; id<=num; id+=id&(-id)) fen[id] += w;
        }

        ll get(int p){
            ll times = positions + num - lower_bound(positions,positions+num,p); // number >= p
            ll ans = times * sum; // big updates summed
            int r = times;
            for(;r>0;r-=r&(-r)) ans += fen[r]; // point query
            return ans;
        }
    };

    wholeblock whole[(N+B-1)/B];
    ll smallsteps[N];

    int a[N];

    void update(int p, ll w){ // assume p is the number of blocks
        // do large blocks
        int L = 0;
        int id = 0;
        for (; L+B <= p; ++id, L += B){
            whole[id].sum += w;
        }    
        // do last block
        for(int i = 0;L+i<p;++i){
            whole[id].update(i,w);
            smallsteps[L+i] += w;
        }
    }

    ll query(int p, int d){
        ll ans = 0;

        // do big steps with blocks
        int L = 0;
        int id = 0;
        for(;L+B <= p; L+=B, ++id){
            ans += whole[id].get(d);
        }

        // do small steps
        for(int i = 0; L+i < p; ++i){
            ans += (d<=a[L+i] ? smallsteps[L+i] + whole[id].sum : 0);
        }

        return ans;
    }

    void solve(int n, int m, int z){

        rep(i,0,n){
            int x; cin >> x;
            a[i] = x;
            whole[i/B].insert(x);
        }
        rep(i,0,(N+B-1)/B){
            whole[i].build();
        }

        rep(i,0,m+z){
            int t; cin >> t;
            if (t==1){
                int p,w; cin >> p >> w;
                update(p,w);
            }else{
                int p,d; cin >> p >> d;
                cout << query(p,d) << '\n';
            }
        }
    }
}

namespace bigB{
    const int N = 1e6+500;
    const int B = 4600; // nsqrt(n)

    struct wholeblock{
        int positions[B];
        int ord[B], invord[B];
        int num = 0;

        ll sum = 0; // when we update whole block
        void insert(int x){
            positions[num] = x;
            ord[num] = num;
            ++num;
        }
        void build(){
            rep(i,0,num+1) fen[i] = 0;
            sort(ord,ord+num,[&](int i, int j){
                return positions[i] < positions[j];
            });
            rep(i,0,num) invord[ord[i]] = i;
            vi rp(num);
            rep(i,0,num) rp[i] = positions[ord[i]];
            rep(i,0,num) positions[i] = rp[i];
        }

        ll fen[B+1];

        // range update
        void update(int i, ll w){
            int id = num - invord[i%B];
            for(id; id<=num; id+=id&(-id)) fen[id] += w;
        }

        ll get(int p){
            ll times = positions + num - lower_bound(positions,positions+num,p); // number >= p
            ll ans = times * sum; // big updates summed
            int r = times;
            for(;r>0;r-=r&(-r)) ans += fen[r]; // point query
            return ans;
        }
    };

    wholeblock whole[(N+B-1)/B];
    ll smallsteps[N];

    int a[N];

    void update(int p, ll w){ // assume p is the number of blocks
        // do large blocks
        int L = 0;
        int id = 0;
        for (; L+B <= p; ++id, L += B){
            whole[id].sum += w;
        }    
        // do last block
        for(int i = 0;L+i<p;++i){
            whole[id].update(i,w);
            smallsteps[L+i] += w;
        }
    }

    ll query(int p, int d){
        ll ans = 0;

        // do big steps with blocks
        int L = 0;
        int id = 0;
        for(;L+B <= p; L+=B, ++id){
            ans += whole[id].get(d);
        }

        // do small steps
        for(int i = 0; L+i < p; ++i){
            ans += (d<=a[L+i] ? smallsteps[L+i] + whole[id].sum : 0);
        }

        return ans;
    }

    void solve(int n, int m, int z){
        rep(i,0,n){
            int x; cin >> x;
            a[i] = x;
            whole[i/B].insert(x);
        }
        rep(i,0,(N+B-1)/B){
            whole[i].build();
        }

        rep(i,0,m+z){
            int t; cin >> t;
            if (t==1){
                int p,w; cin >> p >> w;
                update(p,w);
            }else{
                int p,d; cin >> p >> d;
                cout << query(p,d) << '\n';
            }
        }
    }
}

namespace smallN{
    const int N = 220500;
    const int B = 900; // nsqrt(n)

    struct wholeblock{
        int positions[B];
        int ord[B], invord[B];
        int num = 0;

        ll sum = 0; // when we update whole block
        void insert(int x){
            positions[num] = x;
            ord[num] = num;
            ++num;
        }
        void build(){
            rep(i,0,num+1) fen[i] = 0;
            sort(ord,ord+num,[&](int i, int j){
                return positions[i] < positions[j];
            });
            rep(i,0,num) invord[ord[i]] = i;
            vi rp(num);
            rep(i,0,num) rp[i] = positions[ord[i]];
            rep(i,0,num) positions[i] = rp[i];
        }

        ll fen[B+1];

        // range update
        void update(int i, ll w){
            int id = num - invord[i%B];
            for(id; id<=num; id+=id&(-id)) fen[id] += w;
        }

        
        ll get(int p){
            ll times = positions + num - lower_bound(positions,positions+num,p); // number >= p
            ll ans = times * sum; // big updates summed
            int r = times;
            for(;r>0;r-=r&(-r)) ans += fen[r]; // point query
            return ans;
        }
    };

    wholeblock whole[(N+B-1)/B];
    ll smallsteps[N];

    int a[N];

    void update(int p, ll w){ // assume p is the number of blocks
        // do large blocks
        int L = 0;
        int id = 0;
        for (; L+B <= p; ++id, L += B){
            whole[id].sum += w;
        }    
        // do last block
        for(int i = 0;L+i<p;++i){
            whole[id].update(i,w);
            smallsteps[L+i] += w;
        }
    }

    ll query(int p, int d){
        ll ans = 0;

        // do big steps with blocks
        int L = 0;
        int id = 0;
        for(;L+B <= p; L+=B, ++id){
            ans += whole[id].get(d);
        }

        // do small steps
        for(int i = 0; L+i < p; ++i){
            ans += (d<=a[L+i] ? smallsteps[L+i] + whole[id].sum : 0);
        }

        return ans;
    }

    void solve(int n, int m, int z){
        
        rep(i,0,n){
            int x; cin >> x;
            a[i] = x;
            whole[i/B].insert(x);
        }
        rep(i,0,(N+B-1)/B){
            whole[i].build();
        }

        rep(i,0,m+z){
            int t; cin >> t;
            if (t==1){
                int p,w; cin >> p >> w;
                update(p,w);
            }else{
                int p,d; cin >> p >> d;
                cout << query(p,d) << '\n';
            }
        }
    }
}

int cutoff = 220000;

/*

query wants low number of blocks -> B large
update wants small blocks -> B small
if N small then block small anyways.
one out of 3 is always smaller than cutoff

*/

int main(){

    cin.tie(NULL),cin.sync_with_stdio(false);
    int n,m,z; cin >> n >> m >> z;

    if (n<cutoff) smallN::solve(n,m,z);
    else if (z*2 > m) bigB::solve(n,m,z);
    else smallB::solve(n,m,z);
}