#include <bits/stdc++.h>
using namespace std;
struct Node {
  long long int l = 0, r = 0, p = 0;
  long long int size = 0, sumv = 0, val = 0, X = 0, sumx = 0, lazy = 0;
  Node(long long int x, long long int v) {
    X = sumx = x;
    val = sumv = v;
    size = 1;
  }
  Node() {}
} v[100005];
namespace SplayTree {
void push(long long int j) {
  if (!j) return;
  long long int l = v[j].l;
  long long int r = v[j].r;
  v[j].val += v[j].X * v[j].lazy;
  v[j].sumv += v[j].sumx * v[j].lazy;
  if (l) {
    v[l].lazy += v[j].lazy;
  }
  if (r) {
    v[r].lazy += v[j].lazy;
  }
  v[j].lazy = 0;
}
void up(long long int j) {
  if (!j) return;
  long long int l = v[j].l;
  long long int r = v[j].r;
  push(j);
  push(l);
  push(r);
  v[j].size = 1;
  v[j].sumx = v[j].X;
  v[j].sumv = v[j].val;
  if (l) {
    v[j].size += v[l].size;
    v[j].sumx += v[l].sumx;
    v[j].sumv += v[l].sumv;
    v[l].p = j;
  }
  if (r) {
    v[j].size += v[r].size;
    v[j].sumx += v[r].sumx;
    v[j].sumv += v[r].sumv;
    v[r].p = j;
  }
}
bool nroot(long long int j) {
  long long int p = v[j].p;
  return j && p && (v[p].l == j || v[p].r == j);
}
bool is_left(long long int j, long long int i) {
  assert(i && j);
  return v[i].l == j;
}
void Rotate(long long int j) {
  long long int p = v[j].p;
  long long int pp = v[p].p;
  assert(j && p);
  push(p);
  push(j);
  if (nroot(p)) is_left(p, pp) ? v[pp].l = j : v[pp].r = j;
  v[j].p = pp;
  if (is_left(j, p)) {
    v[p].l = v[j].r;
    v[j].r = p;
  } else {
    v[p].r = v[j].l;
    v[j].l = p;
  }
  up(p);
  up(j);
}
void Splay(long long int j) {
  up(j);
  while (nroot(j)) {
    long long int p = v[j].p;
    long long int pp = v[p].p;
    if (nroot(p)) is_left(j, p) ^ is_left(p, pp) ? Rotate(j) : Rotate(p);
    Rotate(j);
  }
}
void cut(long long int j, long long int& i) {
  v[i].p = 0;
  i = 0;
  up(j);
}
void link(long long int j, long long int i) {
  Splay(j);
  Splay(i);
  v[j].r = i;
  up(j);
}
};  // namespace SplayTree
using namespace SplayTree;
long long int n, q;
vector<long long int> X(100005);
vector<long long int> K(100005);
vector<pair<long long int, long long int> > Q(100005);
vector<long long int> ans(100005);
void solve() {
  map<long long int, long long int> P;
  for (long long int i = 1; i <= n; i++) P[X[i]] = i, v[i] = Node();
  long long int ind = 1;
  long long int pr = 0;
  for (auto p : P) {
    v[p.second] = Node(p.first, (ind - 1) * p.first);
    if (pr) v[pr].r = p.second;
    up(pr);
    Splay(pr = p.second);
    ind++;
  }
  for (long long int i = 0; i < q; i++) {
    long long int x = Q[i].first;
    long long int y = Q[i].second;
    if (K[i] == 1) {
      long long int d = v[x].X;
      auto itr = P.find(d);
      Splay(x);
      v[v[x].r].lazy--;
      cut(x, v[x].l);
      cut(x, v[x].r);
      if (itr != P.begin() && next(itr) != P.end()) {
        link(prev(itr)->second, next(itr)->second);
      }
      P.erase(itr);
      d += y;
      v[x] = Node(d, 0);
      auto L = P.upper_bound(d);
      if (L != P.begin()) {
        L--;
        Splay(L->second);
        cut(L->second, v[L->second].r);
        v[x] = Node(d, v[L->second].size * d);
        link(L->second, x);
        L++;
      }
      if (L != P.end()) link(x, L->second);
      Splay(x);
      v[v[x].r].lazy++;
      P.insert({d, x});
    } else {
      auto L = P.lower_bound(x);
      auto R = P.upper_bound(y);
      if (L == R--) continue;
      long long int dec = 0;
      Splay(L->second);
      dec = v[v[L->second].l].size;
      cut(L->second, v[L->second].l);
      Splay(R->second);
      cut(R->second, v[R->second].r);
      ans[i] += v[R->second].sumv - dec * v[R->second].sumx;
      if (next(R) != P.end()) {
        link(R->second, next(R)->second);
      }
      if (L != P.begin()) {
        link(prev(L)->second, L->second);
      }
    }
  }
}
int32_t main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cin >> n;
  for (long long int i = 1; i <= n; i++) cin >> X[i];
  cin >> q;
  for (long long int i = 0; i < q; i++)
    cin >> K[i] >> Q[i].first >> Q[i].second;
  solve();
  for (long long int i = 1; i <= n; i++) X[i] = -X[i];
  for (long long int i = 0; i < q; i++) {
    if (K[i] == 1)
      Q[i].second = -Q[i].second;
    else
      Q[i] = {-Q[i].second, -Q[i].first};
  }
  solve();
  for (long long int i = 0; i < q; i++)
    if (K[i] == 2) cout << ans[i] << '\n';
}
