#include <bits/stdc++.h>
#define ll long long
#define mk std::make_pair
#define st first
#define nd second

const int MAX_N = 1e5;
int n, q;

ll a[MAX_N+3], b[MAX_N+3];
ll pref[MAX_N+3];
ll t[MAX_N+3];

ll prefpref[MAX_N+3];

struct Node{
    ll sum, max, lazy;
    Node(){
        sum = 0;
        max = -LLONG_MAX;
        lazy = -LLONG_MAX;
    }
};

const int base = 1<<19;
struct SegmentTree{
    Node t[2*base+5];
    SegmentTree(){
        1+1;
    }
    void pushDown(int v, int low, int high){
        ll x = t[v].lazy;
        t[v].max = x;
        ll range = (high-low+1);
        t[v].sum = range * x;
        if (low != high){
            t[v*2].lazy = x;
            t[v*2+1].lazy = x;
        }
        t[v].lazy = -LLONG_MAX;
    }
    int find(ll x, int v, int low, int high){
        if (t[v].lazy != -LLONG_MAX)
            pushDown(v, low, high);
        if (low != high){
            if (t[v*2].lazy != -LLONG_MAX)
                pushDown(v*2, low, (low+high)/2);
            if (t[v*2+1].lazy != -LLONG_MAX)
                pushDown(v*2+1, (low+high)/2+1, high);
        }
        // pierwszy wiekszy badz rowny x
        if (low == high)
            return low;
        if (t[v*2].max >= x)
            return find(x, v*2, low, (low+high)/2);
        else
            return find(x, v*2+1, (low+high)/2+1, high);
    }
    void update(int low, int high, int L, int R, int v, ll x){
        if (low > high || L > R)
            return;
        if (t[v].lazy != -LLONG_MAX)
            pushDown(v, low, high);
        if (low > R || high < L)
            return;
        if (low >= L && high <= R){
            t[v].lazy = x;
            pushDown(v, low, high);
            return;
        }
        int mid = (low + high)/2;
        update(low, mid, L, R, v*2, x);
        update(mid+1, high, L, R, v*2+1, x);
        t[v].sum = (t[v*2].sum + t[v*2+1].sum);
        t[v].max = std::max(t[v*2].max, t[v*2+1].max);
    }
    ll query(int low, int high, int L, int R, int v){
        if (low > high || L > R)
            return 0;
        if (t[v].lazy != -LLONG_MAX)
            pushDown(v, low, high);
        if (low > R || high < L)
            return 0;
        if (low >= L && high <= R)
            return t[v].sum;
        int mid = (low + high)/2;
        return query(low, mid, L, R, v*2) + query(mid+1, high, L, R, v*2+1);
    }
};

void input(){
    std::cin >> n;
    for (int i = 1; i <= n; i++)
        std::cin >> a[i];
    for (int i = 1; i <= n-1; i++)
        std::cin >> b[i];
    pref[1] = 0;
    for (int i = 2; i <= n; i++)
        pref[i] = (pref[i-1] + b[i-1]);
    for (int i = 1; i <= n; i++)
        t[i] = a[i] - pref[i];
    prefpref[0] = 0;
    for (int i = 1; i <= n; i++)
        prefpref[i] = prefpref[i-1] + pref[i];
}

SegmentTree tree;

int main(){
    std::ios_base::sync_with_stdio(0); std::cin.tie(NULL);
    input();
    for (int i = 1; i <= n; i++)
        tree.update(1, n, i, i, 1, t[i]);
    std::cin >> q;
    char c; ll x, y;
    while (q--){
        std::cin >> c >> x >> y;
        if (c == '+'){
            ll value = tree.query(1, n, x, x, 1);
            if (tree.t[1].max < value + y)
                tree.update(1, n, x, n, 1, value + y);
            else{
                int last = tree.find(value + y, 1, 1, n);
                tree.update(1, n, x, last-1, 1, value + y);
            }
        }
        else{
            ll sum1 = tree.query(1, n, x, y, 1);
            sum1 += (prefpref[y] - prefpref[x-1]);
            std::cout << sum1 << "\n";
        }
    }
}


#include <bits/stdc++.h>
#define ll long long
#define mk std::make_pair
#define st first
#define nd second

const int MAX_N = 1e5;
int n, q;

ll a[MAX_N+3], b[MAX_N+3];
ll pref[MAX_N+3];
ll t[MAX_N+3];

ll prefpref[MAX_N+3];

struct Node{
    ll sum, max, lazy;
    Node(){
        sum = max = 0;
        lazy = -1;
    }
};

const int base = 1<<19;
struct SegmentTree{
    Node t[2*base+5];
    SegmentTree(){
        1+1;
    }
    int find(ll x, int v, int low, int high){
        // pierwszy wiekszy badz rowny x
        if (low == high)
            return low;
        if (t[v*2].max >= x)
            return find(x, v*2, low, (low+high)/2);
        else
            return find(x, v*2+1, (low+high)/2+1, high);
    }
    void pushDown(int v, int low, int high){
        ll x = t[v].lazy;
        t[v].max = x;
        ll range = (high-low+1);
        t[v].sum = range * x;
        if (low != high){
            t[v*2].lazy = x;
            t[v*2+1].lazy = x;
        }
        t[v].lazy = -1;
    }
    void update(int low, int high, int L, int R, int v, ll x){
        if (low > high || L > R)
            return;
        if (t[v].lazy != -1)
            pushDown(v, low, high);
        if (low > R || high < L)
            return;
        if (low >= L && high <= R){
            t[v].lazy = x;
            pushDown(v, low, high);
            return;
        }
        int mid = (low + high)/2;
        update(low, mid, L, R, v*2, x);
        update(mid+1, high, L, R, v*2+1, x);
        t[v].sum = (t[v*2].sum + t[v*2+1].sum);
        t[v].max = std::max(t[v*2].max, t[v*2+1].max);
    }
    ll query(int low, int high, int L, int R, int v){
        if (low > high || L > R)
            return 0;
        if (t[v].lazy != -1)
            pushDown(v, low, high);
        if (low > R || high < L)
            return 0;
        if (low >= L && high <= R)
            return t[v].sum;
        int mid = (low + high)/2;
        return query(low, mid, L, R, v*2) + query(mid+1, high, L, R, v*2+1);
    }
};

void input(){
    std::cin >> n;
    for (int i = 1; i <= n; i++)
        std::cin >> a[i];
    for (int i = 1; i <= n-1; i++)
        std::cin >> b[i];
    pref[1] = 0;
    for (int i = 2; i <= n; i++)
        pref[i] = (pref[i-1] + b[i-1]);
    for (int i = 1; i <= n; i++)
        t[i] = a[i] - pref[i];
    prefpref[0] = 0;
    for (int i = 1; i <= n; i++)
        prefpref[i] = prefpref[i-1] + pref[i];
}

SegmentTree tree;

int main(){
    std::ios_base::sync_with_stdio(0); std::cin.tie(NULL);
    input();
    for (int i = 1; i <= n; i++)
        tree.update(1, n, i, i, 1, t[i]);
    std::cin >> q;
    char c; ll x, y;
    while (q--){
        std::cin >> c >> x >> y;
        if (c == '+'){
            ll value = tree.query(1, n, x, x, 1);
            if (tree.t[1].max < value + y)
                tree.update(1, n, x, n, 1, value + y);
            else{
                int last = tree.find(value + y, 1, 1, n);
                tree.update(1, n, x, last-1, 1, value+y);
            }
        }
        else{
            ll sum1 = tree.query(1, n, x, y, 1);
            sum1 += (prefpref[y] - prefpref[x-1]);
            std::cout << sum1 << "\n";
        }
    }
}


#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <cmath>
#include <utility>
#include <algorithm>
#include <bitset>
#include <climits>
#include <random>
#include <chrono>
#include <cassert>

using namespace std;

typedef long long ll;

#define pii pair< int, int >
#define pll pair< ll, ll >
#define N 100001

int n, q, parent[N];
ll a[N], b[N], c[N], T1[N], T2[N];
char ch[2];

int Find(int i){
  return c[i] >= 0 ? parent[i] : parent[i] = Find(parent[i + 1]);
}

void Update(ll T[], int i, ll x){
  for( ; i < N; i += (i & -i)){
    T[i] += x;
  }
}

void Update(int i, int j, ll x){
  Update(T1, i, x);
  Update(T1, j + 1, -x);
  Update(T2, i, -(i - 1) * x);
  Update(T2, j + 1, j * x);
  c[j] -= x;
}

ll Query(ll T[], int i){
  ll ans = 0;
  for( ; i > 0; i -= (i & -i)){
    ans += T[i];
  }
  return ans;
}

ll Query(int i){
  ll a = Query(T1, i), b = Query(T2, i);
  return a * i + b;
}

ll Query(int i, int j){
  return Query(j) - Query(i - 1);
}

void Update(int i, int x){
  if(x == 0){
    return ;
  }
  int j = Find(i);
  Update(i, j, x);
  for( ; j <= n; ++j){
    if(c[j] >= 0){
      break;
    }
    else{
      Update(j + 1, j + 1, Query(j, j) + b[j] - Query(j + 1, j + 1));
    }
  }
}

int main(){
  scanf("%d", &n);

  for(int i = 1; i <= n; ++i){
    scanf("%lld", &a[i]);
  }

  for(int i = 1; i < n; ++i){
    scanf("%lld", &b[i]);
  }

  for(int i = 1; i <= n; ++i){
    Update(i, i, a[i]);
  }

  for(int i = 1; i < n; ++i){
    c[i] = a[i + 1] - a[i] - b[i];
  }

  c[n] = LLONG_MAX;
  parent[n] = n;
  for(int i = n - 1; i > 0; --i){
    parent[i] = i;
  }

  scanf("%d", &q);
  while(q--){
    int i, j;
    scanf("%s%d%d", ch, &i, &j);
    if(ch[0] == '+'){
      Update(i, j);
    }
    else{
      printf("%lld\n", Query(i, j));
    }
  }
  return 0;
}


#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <cmath>
#include <utility>
#include <algorithm>
#include <bitset>
#include <climits>
#include <random>
#include <chrono>
#include <cassert>

using namespace std;

typedef long long ll;

#define pii pair< int, int >
#define pll pair< ll, ll >
#define N 100002
#define B 18
#define M (1 << B)

int n, a[N];
ll b[N];
char ch[2];

//----------------------------------------- Segment Tree -----------------------------------------//
int length[M];
ll lazyValue[M], s[M];

void Combine(int k){
  s[k] = s[2 * k + 1] + s[2 * k + 2];
}

void BuildSegmentTree(int k, int l, int r){
  if(l == r){
    s[k] = a[l];
  }
  else{
    BuildSegmentTree(2 * k + 1, l, (l + r) / 2);
    BuildSegmentTree(2 * k + 2, (l + r) / 2 + 1, r);
    Combine(k);
  }
  length[k] = r - l + 1;
}

void UpdateNode(int k, int x){
  lazyValue[k] += x;
  s[k] += 1ll * x * length[k];
}

void LazyUpdateChildren(int k){
  if(lazyValue[k] == 0){
    return ;
  }

  UpdateNode(2 * k + 1, lazyValue[k]);
  UpdateNode(2 * k + 2, lazyValue[k]);
  lazyValue[k] = 0;
}

void Update(int k, int l, int r, int ql, int qr, int x){
  if(qr < l || r < ql){
    return ;
  }

  if(ql <= l && r <= qr){
    UpdateNode(k, x);
    return ;
  }

  LazyUpdateChildren(k);
  Update(2 * k + 1, l, (l + r) / 2, ql, qr, x);
  Update(2 * k + 2, (l + r) / 2 + 1, r, ql, qr, x);
  Combine(k);
}

ll Query(int k, int l, int r, int ql, int qr){
  if(qr < l || r < ql){
    return 0;
  }

  if(ql <= l && r <= qr){
    return s[k];
  }

  LazyUpdateChildren(k);
  ll ans = Query(2 * k + 1, l, (l + r) / 2, ql, qr) + Query(2 * k + 2, (l + r) / 2 + 1, r, ql, qr);
  Combine(k);

  return ans;
}
//-------------------------------------- Segment Tree Ends --------------------------------------//

set<int> S;

void PreProcess(){
  for(int i = 2; i <= n; ++i){
    b[i] += b[i - 1];
  }

  for(int i = n; i > 0; --i){
    b[i] = a[i] - b[i];
    S.insert(i);
  }
  S.insert(n + 1);
  b[n + 1] = LLONG_MAX;

  BuildSegmentTree(0, 1, n);
}

void Update(int i, int x){
  if(x == 0){
    return;
  }

  b[i] = b[*prev(S.upper_bound(i))];
  S.insert(i);

  int bi = b[i] + x;
  while(true){
    auto jt = S.lower_bound(i);
    int j = *jt;
    if(bi < b[j]){
      break;
    }
    int k = *next(jt);
    Update(0, 1, n, j, k - 1, bi - b[j]);
    S.erase(j);
  }

  b[i] = bi;
  S.insert(i);
}

ll Query(int i, int j){
  return Query(0, 1, n, i, j);
}

int main(){
  scanf("%d", &n);

  for(int i = 1; i <= n; ++i){
    scanf("%d", &a[i]);
  }

  for(int i = 2; i <= n; ++i){
    scanf("%lld", &b[i]);
  }

  PreProcess();

  int q;
  scanf("%d", &q);
  while(q--){
    int i, j;
    scanf("%s%d%d", ch, &i, &j);
    if(ch[0] == '+'){
      Update(i, j);
    }
    else{
      printf("%lld\n", Query(i, j));
    }
  }

  return 0;
}


#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <cmath>
#include <utility>
#include <algorithm>
#include <bitset>
#include <climits>
#include <random>
#include <chrono>
#include <cassert>

using namespace std;

typedef long long ll;

#define pii pair< int, int >
#define pll pair< ll, ll >
#define N 100002
#define B 18
#define M (1 << B)

int n, a[N];
ll b[N];
char ch[2];

//----------------------------------------- Segment Tree -----------------------------------------//
int length[M];
ll lazyValue[M], s[M];

void Combine(int k){
  s[k] = s[2 * k + 1] + s[2 * k + 2];
}

void BuildSegmentTree(int k, int l, int r){
  if(l == r){
    s[k] = a[l];
  }
  else{
    BuildSegmentTree(2 * k + 1, l, (l + r) / 2);
    BuildSegmentTree(2 * k + 2, (l + r) / 2 + 1, r);
    Combine(k);
  }
  length[k] = r - l + 1;
}

void UpdateNode(int k, int x){
  lazyValue[k] += x;
  s[k] += 1ll * x * length[k];
}

void LazyUpdateChildren(int k){
  if(lazyValue[k] == 0){
    return ;
  }

  UpdateNode(2 * k + 1, lazyValue[k]);
  UpdateNode(2 * k + 2, lazyValue[k]);
  lazyValue[k] = 0;
}

void Update(int k, int l, int r, int ql, int qr, int x){
  if(qr < l || r < ql){
    return ;
  }

  if(ql <= l && r <= qr){
    UpdateNode(k, x);
    return ;
  }

  LazyUpdateChildren(k);
  Update(2 * k + 1, l, (l + r) / 2, ql, qr, x);
  Update(2 * k + 2, (l + r) / 2 + 1, r, ql, qr, x);
  Combine(k);
}

ll Query(int k, int l, int r, int ql, int qr){
  if(qr < l || r < ql){
    return 0;
  }

  if(ql <= l && r <= qr){
    return s[k];
  }

  LazyUpdateChildren(k);
  ll ans = Query(2 * k + 1, l, (l + r) / 2, ql, qr) + Query(2 * k + 2, (l + r) / 2 + 1, r, ql, qr);
  Combine(k);

  return ans;
}
//-------------------------------------- Segment Tree Ends --------------------------------------//

set<int> S;

void PreProcess(){
  for(int i = 2; i <= n; ++i){
    b[i] += b[i - 1];
  }

  for(int i = n; i > 0; --i){
    b[i] = a[i] - b[i];
    S.insert(i);
  }
  S.insert(n + 1);
  b[n + 1] = LLONG_MAX;

  BuildSegmentTree(0, 1, n);
}

void Update(int i, int x){
  if(x == 0){
    return;
  }

  b[i] = b[*prev(S.upper_bound(i))];
  S.insert(i);

  ll bi = b[i] + x;
  while(true){
    auto jt = S.lower_bound(i);
    int j = *jt;
    if(bi < b[j]){
      break;
    }
    int k = *next(jt);
    Update(0, 1, n, j, k - 1, bi - b[j]);
    S.erase(j);
  }

  b[i] = bi;
  S.insert(i);
}

ll Query(int i, int j){
  return Query(0, 1, n, i, j);
}

int main(){
  scanf("%d", &n);

  for(int i = 1; i <= n; ++i){
    scanf("%d", &a[i]);
  }

  for(int i = 2; i <= n; ++i){
    scanf("%lld", &b[i]);
  }

  PreProcess();

  int q;
  scanf("%d", &q);
  while(q--){
    int i, j;
    scanf("%s%d%d", ch, &i, &j);
    if(ch[0] == '+'){
      Update(i, j);
    }
    else{
      printf("%lld\n", Query(i, j));
    }
  }

  return 0;
}


#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <cmath>
#include <utility>
#include <algorithm>
#include <bitset>
#include <climits>
#include <random>
#include <chrono>
#include <cassert>

using namespace std;

typedef long long ll;

#define pii pair< int, int >
#define pll pair< ll, ll >
#define N 100001
#define B 18
#define M (1 << B)

int n, a[N];
ll b[N];
char ch[2];

//----------------------------------------- Segment Tree -----------------------------------------//
int length[M];
ll lazyValue[M], s[M];

void Combine(int k){
  s[k] = s[2 * k + 1] + s[2 * k + 2];
}

void BuildSegmentTree(int k, int l, int r){
  if(l == r){
    s[k] = a[l];
  }
  else{
    BuildSegmentTree(2 * k + 1, l, (l + r) / 2);
    BuildSegmentTree(2 * k + 2, (l + r) / 2 + 1, r);
    Combine(k);
  }
  length[k] = r - l + 1;
}

void UpdateNode(int k, int x){
  lazyValue[k] += x;
  s[k] += 1ll * x * length[k];
}

void LazyUpdateChildren(int k){
  if(lazyValue[k] == 0){
    return ;
  }

  UpdateNode(2 * k + 1, lazyValue[k]);
  UpdateNode(2 * k + 2, lazyValue[k]);
  lazyValue[k] = 0;
}

void Update(int k, int l, int r, int ql, int qr, int x){
  if(qr < l || r < ql){
    return ;
  }

  if(ql <= l && r <= qr){
    UpdateNode(k, x);
    return ;
  }

  LazyUpdateChildren(k);
  Update(2 * k + 1, l, (l + r) / 2, ql, qr, x);
  Update(2 * k + 2, (l + r) / 2 + 1, r, ql, qr, x);
  Combine(k);
}

ll Query(int k, int l, int r, int ql, int qr){
  if(qr < l || r < ql){
    return 0;
  }

  if(ql <= l && r <= qr){
    return s[k];
  }

  LazyUpdateChildren(k);
  ll ans = Query(2 * k + 1, l, (l + r) / 2, ql, qr) + Query(2 * k + 2, (l + r) / 2 + 1, r, ql, qr);
  Combine(k);

  return ans;
}
//-------------------------------------- Segment Tree Ends --------------------------------------//

map< ll, int > C;
set<int> S;

void PreProcess(){
  for(int i = 2; i <= n; ++i){
    b[i] += b[i - 1];
  }

  for(int i = n; i > 0; --i){
    b[i] = a[i] - b[i];
    C[b[i]] = i;
  }
  C[LLONG_MAX] = n + 1;

  for(auto it : C){
    S.insert(it.second);
  }

  BuildSegmentTree(0, 1, n);
}

void Update(int i, int x){
  if(x == 0){
    return;
  }

  ll bi = b[*prev(S.upper_bound(i))];
  ll bj = bi + x;

  while(true){
    auto it = C.upper_bound(bi);
    if(bj <= it->first){
      break;
    }
    S.erase(it->second);
    C.erase(it);
  }

  int j = C.upper_bound(bi)->second - 1;
  C[bj] = i;
  b[i] = bj;
  S.insert(i);

  Update(0, 1, n, i, j, x);
}

ll Query(int i, int j){
  return Query(0, 1, n, i, j);
}

int main(){
  scanf("%d", &n);

  for(int i = 1; i <= n; ++i){
    scanf("%d", &a[i]);
  }

  for(int i = 2; i <= n; ++i){
    scanf("%lld", &b[i]);
  }

  PreProcess();

  int q;
  scanf("%d", &q);
  while(q--){
    int i, j;
    scanf("%s%d%d", ch, &i, &j);
    if(ch[0] == '+'){
      Update(i, j);
    }
    else{
      printf("%lld\n", Query(i, j));
    }
  }

  return 0;
}


#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <cmath>
#include <utility>
#include <algorithm>
#include <bitset>
#include <climits>
#include <random>
#include <chrono>
#include <cassert>

using namespace std;

typedef long long ll;

#define pii pair< int, int >
#define pll pair< ll, ll >
#define N 100001
#define B 18
#define M (1 << B)

int n, a[N];
ll b[N];
char ch[2];

//----------------------------------------- Segment Tree -----------------------------------------//
int length[M];
ll lazyValue[M], s[M];

void Combine(int k){
  s[k] = s[2 * k + 1] + s[2 * k + 2];
}

void BuildSegmentTree(int k, int l, int r){
  if(l == r){
    s[k] = a[l];
  }
  else{
    BuildSegmentTree(2 * k + 1, l, (l + r) / 2);
    BuildSegmentTree(2 * k + 2, (l + r) / 2 + 1, r);
    Combine(k);
  }
  length[k] = r - l + 1;
}

void UpdateNode(int k, int x){
  lazyValue[k] += x;
  s[k] += 1ll * x * length[k];
}

void LazyUpdateChildren(int k){
  if(lazyValue[k] == 0){
    return ;
  }

  UpdateNode(2 * k + 1, lazyValue[k]);
  UpdateNode(2 * k + 2, lazyValue[k]);
  lazyValue[k] = 0;
}

void Update(int k, int l, int r, int ql, int qr, int x){
  if(qr < l || r < ql){
    return ;
  }

  if(ql <= l && r <= qr){
    UpdateNode(k, x);
    return ;
  }

  LazyUpdateChildren(k);
  Update(2 * k + 1, l, (l + r) / 2, ql, qr, x);
  Update(2 * k + 2, (l + r) / 2 + 1, r, ql, qr, x);
  Combine(k);
}

ll Query(int k, int l, int r, int ql, int qr){
  if(qr < l || r < ql){
    return 0;
  }

  if(ql <= l && r <= qr){
    return s[k];
  }

  LazyUpdateChildren(k);
  ll ans = Query(2 * k + 1, l, (l + r) / 2, ql, qr) + Query(2 * k + 2, (l + r) / 2 + 1, r, ql, qr);
  Combine(k);

  return ans;
}
//-------------------------------------- Segment Tree Ends --------------------------------------//

map< ll, int > C;
set<int> S;

void PreProcess(){
  for(int i = 2; i <= n; ++i){
    b[i] += b[i - 1];
  }

  for(int i = n; i > 0; --i){
    b[i] = a[i] - b[i];
    C[b[i]] = i;
  }
  C[LLONG_MAX] = n + 1;

  for(auto it : C){
    S.insert(it.second);
  }

  BuildSegmentTree(0, 1, n);
}

void Update(int i, int x){
  if(x == 0){
    return;
  }

  ll bi = b[*prev(S.upper_bound(i))];
  ll bj = bi + x;

  while(true){
    auto it = C.upper_bound(bi);
    if(bj <= it->first){
      break;
    }
    S.erase(it->second);
    C.erase(it);
  }

  int j = C.upper_bound(bi)->second - 1;
  C[i] = bj;
  b[i] = bj;
  S.insert(i);

  Update(0, 1, n, i, j, x);
}

ll Query(int i, int j){
  return Query(0, 1, n, i, j);
}

int main(){
  scanf("%d", &n);

  for(int i = 1; i <= n; ++i){
    scanf("%d", &a[i]);
  }

  for(int i = 2; i <= n; ++i){
    scanf("%lld", &b[i]);
  }

  PreProcess();

  int q;
  scanf("%d", &q);
  while(q--){
    int i, j;
    scanf("%s%d%d", ch, &i, &j);
    if(ch[0] == '+'){
      Update(i, j);
    }
    else{
      printf("%lld\n", Query(i, j));
    }
  }

  return 0;
}


#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <cmath>
#include <utility>
#include <algorithm>
#include <bitset>
#include <climits>
#include <random>
#include <chrono>
#include <cassert>

using namespace std;

typedef long long ll;

#define pii pair< int, int >
#define pll pair< ll, ll >
#define N 100002
#define B 18
#define M (1 << B)

int n, a[N];
ll b[N];
char ch[2];

//----------------------------------------- Segment Tree -----------------------------------------//
int length[M];
ll lazyValue[M], s[M];

void Combine(int k){
  s[k] = s[2 * k + 1] + s[2 * k + 2];
}

void BuildSegmentTree(int k, int l, int r){
  if(l == r){
    s[k] = a[l];
  }
  else{
    BuildSegmentTree(2 * k + 1, l, (l + r) / 2);
    BuildSegmentTree(2 * k + 2, (l + r) / 2 + 1, r);
    Combine(k);
  }
  length[k] = r - l + 1;
}

void UpdateNode(int k, int x){
  lazyValue[k] += x;
  s[k] += 1ll * x * length[k];
}

void LazyUpdateChildren(int k){
  if(lazyValue[k] == 0){
    return ;
  }

  UpdateNode(2 * k + 1, lazyValue[k]);
  UpdateNode(2 * k + 2, lazyValue[k]);
  lazyValue[k] = 0;
}

void Update(int k, int l, int r, int ql, int qr, int x){
  if(qr < l || r < ql){
    return ;
  }

  if(ql <= l && r <= qr){
    UpdateNode(k, x);
    return ;
  }

  LazyUpdateChildren(k);
  Update(2 * k + 1, l, (l + r) / 2, ql, qr, x);
  Update(2 * k + 2, (l + r) / 2 + 1, r, ql, qr, x);
  Combine(k);
}

ll Query(int k, int l, int r, int ql, int qr){
  if(qr < l || r < ql){
    return 0;
  }

  if(ql <= l && r <= qr){
    return s[k];
  }

  LazyUpdateChildren(k);
  ll ans = Query(2 * k + 1, l, (l + r) / 2, ql, qr) + Query(2 * k + 2, (l + r) / 2 + 1, r, ql, qr);
  Combine(k);

  return ans;
}
//-------------------------------------- Segment Tree Ends --------------------------------------//

set<int> S;

void PreProcess(){
  for(int i = 2; i <= n; ++i){
    b[i] += b[i - 1];
  }

  for(int i = n; i > 0; --i){
    b[i] = a[i] - b[i];
    S.insert(i);
  }
  S.insert(n + 1);
  b[n + 1] = LLONG_MAX;

  BuildSegmentTree(0, 1, n);
}

void Update(int i, int x){
  if(x == 0){
    return;
  }

  b[i] = b[*prev(S.upper_bound(i))];
  S.insert(i);

  ll bi = b[i] + x;
  vector<int> v;
  while(true){
    auto jt = S.lower_bound(i);
    int j = *jt;
    v.push_back(j);
    if(bi < b[j]){
      break;
    }
    S.erase(j);
  }

  for(int k = 0; k < v.size() - 1; ++k){
    Update(0, 1, n, v[k], v[k + 1] - 1, bi - b[v[k]]);
  }

  b[i] = bi;
  S.insert(i);
}

ll Query(int i, int j){
  return Query(0, 1, n, i, j);
}

int main(){
  scanf("%d", &n);

  for(int i = 1; i <= n; ++i){
    scanf("%d", &a[i]);
  }

  for(int i = 2; i <= n; ++i){
    scanf("%lld", &b[i]);
  }

  PreProcess();

  int q;
  scanf("%d", &q);
  while(q--){
    int i, j;
    scanf("%s%d%d", ch, &i, &j);
    if(ch[0] == '+'){
      Update(i, j);
    }
    else{
      printf("%lld\n", Query(i, j));
    }
  }

  return 0;
}


#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <cmath>
#include <utility>
#include <algorithm>
#include <bitset>
#include <climits>
#include <random>
#include <chrono>
#include <cassert>

using namespace std;

typedef long long ll;

#define pii pair< int, int >
#define pll pair< ll, ll >
#define N 100001

int n, q, parent[N];
ll a[N], b[N], T1[N], T2[N];
char ch[2];

int Find(int i){
  return a[i] >= 0 ? parent[i] : parent[i] = Find(parent[i + 1]);
}

void Update(ll T[], int i, ll x){
  for( ; i < N; i += (i & -i)){
    T[i] += x;
  }
}

void Update(int i, int j, ll x){
  Update(T1, i, x);
  Update(T1, j + 1, -x);
  Update(T2, i, -(i - 1) * x);
  Update(T2, j + 1, j * x);
}

ll Query(ll T[], int i){
  ll ans = 0;
  for( ; i > 0; i -= (i & -i)){
    ans += T[i];
  }
  return ans;
}

ll Query(int i){
  ll a = Query(T1, i), b = Query(T2, i);
  return a * i + b;
}

ll Query(int i, int j){
  return Query(j) - Query(i - 1);
}

void Update(int i, int x){
  if(x == 0){
    return ;
  }
  int j = Find(i);
  Update(i, j, x);
  for( ; j <= n; ++j){
    a[j] -= x;
    if(a[j] >= 0){
      break;
    }
    else{
      Update(j + 1, j + 1, Query(j, j) + b[j] - Query(j + 1, j + 1));
    }
  }
}

int main(){
  scanf("%d", &n);

  for(int i = 1; i <= n; ++i){
    scanf("%lld", &a[i]);
  }

  for(int i = 1; i < n; ++i){
    scanf("%lld", &b[i]);
  }

  for(int i = 1; i <= n; ++i){
    Update(i, i, a[i]);
  }

  for(int i = 1; i < n; ++i){
    a[i] = a[i + 1] - a[i] - b[i];
  }

  a[n] = LLONG_MAX;
  parent[n] = n;
  for(int i = n - 1; i > 0; --i){
    parent[i] = i;
  }

  scanf("%d", &q);
  while(q--){
    int i, j;
    scanf("%s%d%d", ch, &i, &j);
    if(ch[0] == '+'){
      Update(i, j);
    }
    else{
      printf("%lld\n", Query(i, j));
    }
  }
  return 0;
}


#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <cmath>
#include <utility>
#include <algorithm>
#include <bitset>
#include <climits>
#include <random>
#include <chrono>
#include <cassert>

using namespace std;

typedef long long ll;

#define pii pair< int, int >
#define pll pair< ll, ll >
#define N 100001
#define B 18
#define M (1 << B)

int n, a[N];
ll b[N];
char ch[2];

//----------------------------------------- Segment Tree -----------------------------------------//
int length[M];
ll lazyValue[M], s[M];

void Combine(int k){
  s[k] = s[2 * k + 1] + s[2 * k + 2];
}

void BuildSegmentTree(int k, int l, int r){
  if(l == r){
    s[k] = a[l];
  }
  else{
    BuildSegmentTree(2 * k + 1, l, (l + r) / 2);
    BuildSegmentTree(2 * k + 2, (l + r) / 2 + 1, r);
    Combine(k);
  }
  length[k] = r - l + 1;
}

void UpdateNode(int k, int x){
  lazyValue[k] += x;
  s[k] += 1ll * x * length[k];
}

void LazyUpdateChildren(int k){
  if(lazyValue[k] == 0){
    return ;
  }

  UpdateNode(2 * k + 1, lazyValue[k]);
  UpdateNode(2 * k + 2, lazyValue[k]);
  lazyValue[k] = 0;
}

void Update(int k, int l, int r, int ql, int qr, int x){
  if(qr < l || r < ql){
    return ;
  }

  if(ql <= l && r <= qr){
    UpdateNode(k, x);
    return ;
  }

  LazyUpdateChildren(k);
  Update(2 * k + 1, l, (l + r) / 2, ql, qr, x);
  Update(2 * k + 2, (l + r) / 2 + 1, r, ql, qr, x);
  Combine(k);
}

ll Query(int k, int l, int r, int ql, int qr){
  if(qr < l || r < ql){
    return 0;
  }

  if(ql <= l && r <= qr){
    return s[k];
  }

  LazyUpdateChildren(k);
  ll ans = Query(2 * k + 1, l, (l + r) / 2, ql, qr) + Query(2 * k + 2, (l + r) / 2 + 1, r, ql, qr);
  Combine(k);

  return ans;
}
//-------------------------------------- Segment Tree Ends --------------------------------------//

map< ll, int > C;
set<int> S;

void PreProcess(){
  for(int i = 2; i <= n; ++i){
    b[i] += b[i - 1];
  }

  for(int i = n; i > 0; --i){
    b[i] = a[i] - b[i];
    C[b[i]] = i;
  }
  C[LLONG_MAX] = n + 1;

  for(auto it : C){
    S.insert(it.second);
  }

  BuildSegmentTree(0, 1, n);
}

void Update(int i, int x){
  if(x == 0){
    return;
  }

  int k = i;
  ll bi = b[*prev(S.upper_bound(i))];
  ll bj = bi + x;

  if(S.count(i)){
    C.erase(bi);
  }

  while(true){
    auto it = C.upper_bound(bi);
    int j = it->second - 1;

    Update(0, 1, n, i, j, bj - bi);

    if(bj < it->first){
      break;
    }

    i = j + 1;
    bi = it->first;

    S.erase(it->second);
    C.erase(it);
  }

  C[bj] = k;
  b[k] = bj;
  S.insert(k);
}

ll Query(int i, int j){
  return Query(0, 1, n, i, j);
}

int main(){
  scanf("%d", &n);

  for(int i = 1; i <= n; ++i){
    scanf("%d", &a[i]);
  }

  for(int i = 2; i <= n; ++i){
    scanf("%lld", &b[i]);
  }

  PreProcess();

  int q;
  scanf("%d", &q);
  while(q--){
    int i, j;
    scanf("%s%d%d", ch, &i, &j);
    if(ch[0] == '+'){
      Update(i, j);
    }
    else{
      printf("%lld\n", Query(i, j));
    }
  }

  return 0;
}


#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <cmath>
#include <utility>
#include <algorithm>
#include <bitset>
#include <climits>
#include <random>
#include <chrono>
#include <cassert>

using namespace std;

typedef long long ll;

#define pii pair< int, int >
#define pll pair< ll, ll >
#define N 100001

int n, q, parent[N];
ll a[N], b[N], T1[N], T2[N];
char ch[2];

int Find(int i){
  return a[i] >= 0 ? parent[i] : parent[i] = Find(parent[i + 1]);
}

void Update(ll T[], int i, ll x){
  for( ; i < N; i += (i & -i)){
    T[i] += x;
  }
}

void Update(int i, int j, ll x){
  Update(T1, i, x);
  Update(T1, j + 1, -x);
  Update(T2, i, -(i - 1) * x);
  Update(T2, j + 1, j * x);
}

ll Query(ll T[], int i){
  ll ans = 0;
  for( ; i > 0; i -= (i & -i)){
    ans += T[i];
  }
  return ans;
}

ll Query(int i){
  ll a = Query(T1, i), b = Query(T2, i);
  return a * i + b;
}

ll Query(int i, int j){
  return Query(j) - Query(i - 1);
}

void Update(int i, int x){
  if(x == 0){
    return ;
  }
  int j = Find(i);
  for( ; j <= n; ++j){
    a[j] -= x;
    if(a[j] >= 0){
      break;
    }
  }
  Update(i, j, x);
}

int main(){
  scanf("%d", &n);

  for(int i = 1; i <= n; ++i){
    scanf("%lld", &a[i]);
  }

  for(int i = 1; i < n; ++i){
    scanf("%lld", &b[i]);
  }

  for(int i = 1; i <= n; ++i){
    Update(i, i, a[i]);
  }

  for(int i = 1; i < n; ++i){
    a[i] = a[i + 1] - a[i] - b[i];
  }

  a[n] = LLONG_MAX;
  parent[n] = n;
  for(int i = n - 1; i > 0; --i){
    parent[i] = i;
  }

  scanf("%d", &q);
  while(q--){
    int i, j;
    scanf("%s%d%d", ch, &i, &j);
    if(ch[0] == '+'){
      Update(i, j);
    }
    else{
      printf("%lld\n", Query(i, j));
    }
  }
  return 0;
}


#include <stdio.h>
#include <iostream>
#include <stdlib.h>
#include <string.h>
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#include <cmath>
#include <utility>
#include <algorithm>
#include <bitset>
#include <climits>
#include <random>
#include <chrono>
#include <cassert>

using namespace std;

typedef long long ll;

#define pii pair< int, int >
#define pll pair< ll, ll >
#define N 100001
#define B 18
#define M (1 << B)

int n, a[N];
ll b[N];
char ch[2];

//----------------------------------------- Segment Tree -----------------------------------------//
int length[M];
ll lazyValue[M], s[M];

void Combine(int k){
  s[k] = s[2 * k + 1] + s[2 * k + 2];
}

void BuildSegmentTree(int k, int l, int r){
  if(l == r){
    s[k] = a[l];
  }
  else{
    BuildSegmentTree(2 * k + 1, l, (l + r) / 2);
    BuildSegmentTree(2 * k + 2, (l + r) / 2 + 1, r);
    Combine(k);
  }
  length[k] = r - l + 1;
}

void UpdateNode(int k, int x){
  lazyValue[k] += x;
  s[k] += 1ll * x * length[k];
}

void LazyUpdateChildren(int k){
  if(lazyValue[k] == 0){
    return ;
  }

  UpdateNode(2 * k + 1, lazyValue[k]);
  UpdateNode(2 * k + 2, lazyValue[k]);
  lazyValue[k] = 0;
}

void Update(int k, int l, int r, int ql, int qr, int x){
  if(qr < l || r < ql){
    return ;
  }

  if(ql <= l && r <= qr){
    UpdateNode(k, x);
    return ;
  }

  LazyUpdateChildren(k);
  Update(2 * k + 1, l, (l + r) / 2, ql, qr, x);
  Update(2 * k + 2, (l + r) / 2 + 1, r, ql, qr, x);
  Combine(k);
}

ll Query(int k, int l, int r, int ql, int qr){
  if(qr < l || r < ql){
    return 0;
  }

  if(ql <= l && r <= qr){
    return s[k];
  }

  LazyUpdateChildren(k);
  ll ans = Query(2 * k + 1, l, (l + r) / 2, ql, qr) + Query(2 * k + 2, (l + r) / 2 + 1, r, ql, qr);
  Combine(k);

  return ans;
}
//-------------------------------------- Segment Tree Ends --------------------------------------//

map< ll, int > C;
set<int> S;

void PreProcess(){
  for(int i = 2; i <= n; ++i){
    b[i] += b[i - 1];
  }

  for(int i = n; i > 0; --i){
    b[i] = a[i] - b[i];
    C[b[i]] = i;
  }
  C[LLONG_MAX] = n + 1;

  for(auto it : C){
    S.insert(it.second);
  }

  BuildSegmentTree(0, 1, n);
}

void Update(int i, int x){
  if(x == 0){
    return;
  }

  ll bi = b[*prev(S.upper_bound(i))];
  ll bj = bi + x;

  while(true){
    auto it = C.upper_bound(bi);
    int j = it->second - 1;

    Update(0, 1, n, i, j, bj - bi);

    if(bj <= it->first){
      break;
    }

    i = j + 1;
    bi = it->first;

    S.erase(it->second);
    C.erase(it);
  }

  C[bj] = i;
  b[i] = bj;
  S.insert(i);
}

ll Query(int i, int j){
  return Query(0, 1, n, i, j);
}

int main(){
  scanf("%d", &n);

  for(int i = 1; i <= n; ++i){
    scanf("%d", &a[i]);
  }

  for(int i = 2; i <= n; ++i){
    scanf("%lld", &b[i]);
  }

  PreProcess();

  int q;
  scanf("%d", &q);
  while(q--){
    int i, j;
    scanf("%s%d%d", ch, &i, &j);
    if(ch[0] == '+'){
      Update(i, j);
    }
    else{
      printf("%lld\n", Query(i, j));
    }
  }

  return 0;
}


#include<bits/stdc++.h>
#define fi first
#define se second
#define mk make_pair
#define pb push_back
#define P pair<ll,ll>
#define INF 1e9+9
#define mod 1000000007
#define lowbit(n) n&-n
#define mem(i) memset(i,0,sizeof(i))

using namespace std;
const int maxn=100001;
typedef long long ll;
int n;

ll b[maxn],tt[maxn],k[maxn],a[maxn],s[maxn];
struct
{
	ll l,r,sm,lazy;
}t[maxn*4];
void tup(int k)
{
	t[k].sm=t[k*2].sm+t[k*2+1].sm;
}
void tbu(int k,int l,int r)
{
	t[k].l=l;
	t[k].r=r;
	t[k].lazy=10000000001;
	if(l==r)
	{
		t[k].sm=b[l];
		return ;
	}
	int mid=(l+r)/2;
	tbu(k*2,l,mid);
	tbu(k*2+1,mid+1,r);
	tup(k);
}
void tpush(int k)
{
	if(t[k].lazy==10000000001 || t[k].l==t[k].r)
		return ;
	t[k*2].sm=(t[k*2].r-t[k*2].l+1)*t[k].lazy;
	t[k*2+1].sm=(t[k*2+1].r-t[k*2+1].l+1)*t[k].lazy;
	t[k*2].lazy=t[k].lazy;
	t[k*2+1].lazy=t[k].lazy;
	t[k].lazy=10000000001;
}

void tupdate(int k,int l,int r,ll x)
{
	tpush(k);
	if(t[k].l==l && t[k].r==r)
	{
		t[k].sm=x*(ll)(r-l+1);
		t[k].lazy=x;
		return ;
	}
	int mid=(t[k].l+t[k].r)/2;
	if(r<=mid)
		tupdate(k*2,l,r,x);
	else if(l>mid)
		tupdate(k*2+1,l,r,x);
	else
	{
		tupdate(k*2,l,mid,x);
		tupdate(k*2+1,mid+1,r,x);
	}
	tup(k);
}
ll tqu(int k,int l,int r)
{
	tpush(k);
	if(t[k].l==l && t[k].r==r)
		return t[k].sm;
	int mid=(t[k].l+t[k].r)/2;
	if(r<=mid)
		return tqu(k*2,l,r);
	else if(l>mid)
		return tqu(k*2+1,l,r);
	else
		return tqu(k*2,l,mid)+tqu(k*2+1,mid+1,r);
}

#define mid ((l+r)>>1)
int tfind(int L,ll y)
{
	int l=L,r=n;
	for(int i=0;i<30;i++)
	{
		if(tqu(1,mid,mid)<y)
		{
			l=mid;
		}
		else r=mid;
	}
	//cout<<"__"<<mid<<endl;
	/*
	for(int i=0;i<=3;i++)
	{
		if(mid+i<=L) continue;
		if(mid+i>n ||  tqu(1,mid+i,mid+i)>=y )
		{
			//cout<<mid+i<<endl;
			return mid+i-1;
		}
	}*/
	int tq=mid-1;
	while(tq<=n)
	{
		if(tq<=L)
		{
			tq++;
			continue;
		}
		if(tqu(1,tq,tq)>=y)
			break;
		tq++;
	}
	return tq-1;
}

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

	cin>>n;

	for(int i=1;i<=n;i++)
	{
		cin>>a[i];

	}
	for(int i=1;i<=n-1;i++)
	{
		cin>>k[i];
		tt[i+1]=tt[i]+k[i];

	}
	for(int i=1;i<=n;i++)
	{
		s[i]=s[i-1]+tt[i];
		b[i]=a[i]-tt[i];
	}
	tbu(1,1,n);
	int q;
	cin>>q;
	for(int i=0;i<q;i++)
	{
		char ju;cin>>ju;
		if(ju=='s')
		{
			int l,r;cin>>l>>r;
			cout<<tqu(1,l,r)+s[r]-s[l-1]<<endl;
		}
		else
		{
			int x;
			ll y;cin>>x>>y;
			y=tqu(1,x,x)+y;
			int pos=tfind(x,y);
			//cout<<"="<<pos<<endl;
			tupdate(1,x,pos,y);
		}
	}
}


#include<bits/stdc++.h>
#define fi first
#define se second
#define mk make_pair
#define pb push_back
#define P pair<ll,ll>
#define INF 1e9+9
#define mod 1000000007
#define lowbit(n) n&-n
#define mem(i) memset(i,0,sizeof(i))

using namespace std;
const int maxn=100001;
typedef long long ll;
int n;

ll b[maxn],tt[maxn],k[maxn],a[maxn],s[maxn];
struct
{
	ll l,r,sm,lazy;
}t[maxn*4];
void tup(int k)
{
	t[k].sm=t[k*2].sm+t[k*2+1].sm;
}
void tbu(int k,int l,int r)
{
	t[k].l=l;
	t[k].r=r;
	t[k].lazy=0;
	if(l==r)
	{
		t[k].sm=b[l];
		return ;
	}
	int mid=(l+r)/2;
	tbu(k*2,l,mid);
	tbu(k*2+1,mid+1,r);
	tup(k);
}
void tpush(int k)
{
	if(!t[k].lazy || t[k].l==t[k].r)
		return ;
	t[k*2].sm=(t[k*2].r-t[k*2].l+1)*t[k].lazy;
	t[k*2+1].sm=(t[k*2+1].r-t[k*2+1].l+1)*t[k].lazy;
	t[k*2].lazy=t[k].lazy;
	t[k*2+1].lazy=t[k].lazy;
	t[k].lazy=0;
}

void tupdate(int k,int l,int r,ll x)
{
	tpush(k);
	if(t[k].l==l && t[k].r==r)
	{
		t[k].sm=x*(r-l+1);
		t[k].lazy=x;
		return ;
	}
	int mid=(t[k].l+t[k].r)/2;
	if(r<=mid)
		tupdate(k*2,l,r,x);
	else if(l>mid)
		tupdate(k*2+1,l,r,x);
	else
	{
		tupdate(k*2,l,mid,x);
		tupdate(k*2+1,mid+1,r,x);
	}
	tup(k);
}
ll tqu(int k,int l,int r)
{
	tpush(k);
	if(t[k].l==l && t[k].r==r)
		return t[k].sm;
	int mid=(t[k].l+t[k].r)/2;
	if(r<=mid)
		return tqu(k*2,l,r);
	else if(l>mid)
		return tqu(k*2+1,l,r);
	else
		return tqu(k*2,l,mid)+tqu(k*2+1,mid+1,r);
}

#define mid ((l+r)>>1)
int tfind(int L,ll y)
{
	int l=L,r=n;
	for(int i=0;i<30;i++)
	{
		if(tqu(1,mid,mid)<y)
		{
			l=mid;
		}
		else r=mid;
	}
	//cout<<"__"<<mid<<endl;
	/*
	for(int i=0;i<=3;i++)
	{
		if(mid+i<=L) continue;
		if(mid+i>n ||  tqu(1,mid+i,mid+i)>=y )
		{
			//cout<<mid+i<<endl;
			return mid+i-1;
		}
	}*/
	int tq=mid-1;
	while(tq<=n)
	{
		if(tq<=L)
		{
			tq++;
			continue;
		}
		if(tqu(1,tq,tq)>=y)
			break;
		tq++;
	}
	return tq-1;
}

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

	cin>>n;

	for(int i=1;i<=n;i++)
	{
		cin>>a[i];

	}
	for(int i=1;i<=n-1;i++)
	{
		cin>>k[i];
		tt[i+1]=tt[i]+k[i];

	}
	for(int i=1;i<=n;i++)
	{
		s[i]=s[i-1]+tt[i];
		b[i]=a[i]-tt[i];
	}
	tbu(1,1,n);
	int q;
	cin>>q;
	for(int i=0;i<q;i++)
	{
		char ju;cin>>ju;
		if(ju=='s')
		{
			int l,r;cin>>l>>r;
			cout<<tqu(1,l,r)+s[r]-s[l-1]<<endl;
		}
		else
		{
			int x;
			ll y;cin>>x>>y;
			y=tqu(1,x,x)+y;
			int pos=tfind(x,y);
			//cout<<"="<<pos<<endl;
			tupdate(1,x,pos,y);
		}
	}
}


#include<bits/stdc++.h>
#define fi first
#define se second
#define mk make_pair
#define pb push_back
#define P pair<ll,ll>
#define INF 1e9+9
#define mod 1000000007
#define lowbit(n) n&-n
#define mem(i) memset(i,0,sizeof(i))

using namespace std;
const int maxn=100001;
typedef long long ll;
int n;

ll b[maxn],tt[maxn],k[maxn],a[maxn],s[maxn];
struct
{
	ll l,r,sm,lazy;
}t[maxn*4];
void tup(int k)
{
	t[k].sm=t[k*2].sm+t[k*2+1].sm;
}
void tbu(int k,int l,int r)
{
	t[k].l=l;
	t[k].r=r;
	t[k].lazy=0;
	if(l==r)
	{
		t[k].sm=b[l];
		return ;
	}
	int mid=(l+r)/2;
	tbu(k*2,l,mid);
	tbu(k*2+1,mid+1,r);
	tup(k);
}
void tpush(int k)
{
	if(!t[k].lazy || t[k].l==t[k].r)
		return ;
	t[k*2].sm=(t[k*2].r-t[k*2].l+1)*t[k].lazy;
	t[k*2+1].sm=(t[k*2+1].r-t[k*2+1].l+1)*t[k].lazy;
	t[k*2].lazy=t[k].lazy;
	t[k*2+1].lazy=t[k].lazy;
	t[k].lazy=0;
}

void tupdate(int k,int l,int r,ll x)
{
	tpush(k);
	if(t[k].l==l && t[k].r==r)
	{
		t[k].sm=x*(r-l+1);
		t[k].lazy=x;
		return ;
	}
	int mid=(t[k].l+t[k].r)/2;
	if(r<=mid)
		tupdate(k*2,l,r,x);
	else if(l>mid)
		tupdate(k*2+1,l,r,x);
	else
	{
		tupdate(k*2,l,mid,x);
		tupdate(k*2+1,mid+1,r,x);
	}
	tup(k);
}
ll tqu(int k,int l,int r)
{
	tpush(k);
	if(t[k].l==l && t[k].r==r)
		return t[k].sm;
	int mid=(t[k].l+t[k].r)/2;
	if(r<=mid)
		return tqu(k*2,l,r);
	else if(l>mid)
		return tqu(k*2+1,l,r);
	else
		return tqu(k*2,l,mid)+tqu(k*2+1,mid+1,r);
}

#define mid ((l+r)>>1)
int tfind(int L,ll y)
{
	int l=L,r=n;
	for(int i=0;i<30;i++)
	{
		if(tqu(1,mid,mid)<y)
		{
			l=mid;
		}
		else r=mid;
	}
	//cout<<"__"<<mid<<endl;
	for(int i=0;i<=3;i++)
	{
		if(mid+i<=L) continue;
		if(mid+i>n ||  tqu(1,mid+i,mid+i)>=y )
		{
			//cout<<mid+i<<endl;
			return mid+i-1;
		}
	}
}

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

	cin>>n;

	for(int i=1;i<=n;i++)
	{
		cin>>a[i];

	}
	for(int i=1;i<=n-1;i++)
	{
		cin>>k[i];
		tt[i+1]=tt[i]+k[i];

	}
	for(int i=1;i<=n;i++)
	{
		s[i]=s[i-1]+tt[i];
		b[i]=a[i]-tt[i];
	}
	tbu(1,1,n);
	int q;
	cin>>q;
	for(int i=0;i<q;i++)
	{
		char ju;cin>>ju;
		if(ju=='s')
		{
			int l,r;cin>>l>>r;
			cout<<tqu(1,l,r)+s[r]-s[l-1]<<endl;
		}
		else
		{
			int x;
			ll y;cin>>x>>y;
			y=tqu(1,x,x)+y;
			int pos=tfind(x,y);
			//cout<<"="<<pos<<endl;
			tupdate(1,x,pos,y);
		}
	}
}


#include<bits/stdc++.h>
#define fi first
#define se second
#define mk make_pair
#define pb push_back
#define P pair<ll,ll>
#define INF 1e9+9
#define mod 1000000007
#define lowbit(n) n&-n
#define mem(i) memset(i,0,sizeof(i))

using namespace std;
const int maxn=100001;
typedef long long ll;
int n;

int b[maxn],tt[maxn],k[maxn],a[maxn],s[maxn];
struct
{
	int l,r,sm,lazy;
}t[maxn*4];
void tup(int k)
{
	t[k].sm=t[k*2].sm+t[k*2+1].sm;
}
void tbu(int k,int l,int r)
{
	t[k].l=l;
	t[k].r=r;
	t[k].lazy=0;
	if(l==r)
	{
		t[k].sm=b[l];
		return ;
	}
	int mid=(l+r)/2;
	tbu(k*2,l,mid);
	tbu(k*2+1,mid+1,r);
	tup(k);
}
void tpush(int k)
{
	if(!t[k].lazy || t[k].l==t[k].r)
		return ;
	t[k*2].sm=(t[k*2].r-t[k*2].l+1)*t[k].lazy;
	t[k*2+1].sm=(t[k*2+1].r-t[k*2+1].l+1)*t[k].lazy;
	t[k*2].lazy=t[k].lazy;
	t[k*2+1].lazy=t[k].lazy;
	t[k].lazy=0;
}

void tupdate(int k,int l,int r,int x)
{
	tpush(k);
	if(t[k].l==l && t[k].r==r)
	{
		t[k].sm=x*(r-l+1);
		t[k].lazy=x;
		return ;
	}
	int mid=(t[k].l+t[k].r)/2;
	if(r<=mid)
		tupdate(k*2,l,r,x);
	else if(l>mid)
		tupdate(k*2+1,l,r,x);
	else
	{
		tupdate(k*2,l,mid,x);
		tupdate(k*2+1,mid+1,r,x);
	}
	tup(k);
}
int tqu(int k,int l,int r)
{
	tpush(k);
	if(t[k].l==l && t[k].r==r)
		return t[k].sm;
	int mid=(t[k].l+t[k].r)/2;
	if(r<=mid)
		return tqu(k*2,l,r);
	else if(l>mid)
		return tqu(k*2+1,l,r);
	else
		return tqu(k*2,l,mid)+tqu(k*2+1,mid+1,r);
}

#define mid ((l+r)>>1)
int tfind(int L,int y)
{
	int l=L,r=n;
	for(int i=0;i<30;i++)
	{
		if(tqu(1,mid,mid)<y)
		{
			l=mid;
		}
		else r=mid;
	}
	//cout<<"__"<<mid<<endl;
	for(int i=-2;i<=2;i++)
	{
		if(mid+i<=L) continue;
		if(mid+i>n ||  tqu(1,mid+i,mid+i)>=y )
		{
			//cout<<mid+i<<endl;
			return mid+i-1;
		}
	}
}

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

	cin>>n;

	for(int i=1;i<=n;i++)
	{
		cin>>a[i];

	}
	for(int i=1;i<=n-1;i++)
	{
		cin>>k[i];
		tt[i+1]=tt[i]+k[i];

	}
	for(int i=1;i<=n;i++)
	{
		s[i]=s[i-1]+tt[i];
		b[i]=a[i]-tt[i];
	}
	tbu(1,1,n);
	int q;
	cin>>q;
	for(int i=0;i<q;i++)
	{
		char ju;cin>>ju;
		if(ju=='s')
		{
			int l,r;cin>>l>>r;
			cout<<tqu(1,l,r)+s[r]-s[l-1]<<endl;
		}
		else
		{
			int x,y;cin>>x>>y;
			y=tqu(1,x,x)+y;
			int pos=tfind(x,y);
			//cout<<"="<<pos<<endl;
			tupdate(1,x,pos,y);
		}
	}
}


#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
#define PI 			acos(-1)
#define mp			make_pair
#define pb			push_back
#define all(a)		(a).begin(), (a).end()
#define srt(a)			sort(all(a))
#define mem(a, h)	memset(a, (h), sizeof(a))
#define f 			first
#define s 			second
#define MOD			1000000007
#define MOD1		998244353
#define EPS			1e-9
int in(){int r=0,c;for(c=getchar();c<=32;c=getchar());if(c=='-') return -in();for(;c>32;r=(r<<1)+(r<<3)+c-'0',c=getchar());return r;}

#define inf 0x7fffffff
using namespace std;
//using namespace __gnu_pbds;

typedef long long 		ll;
typedef unsigned long long 		ull;
typedef pair<int, int>  ii;
typedef vector<int>     vi;
typedef vector<ii>      vii;
typedef vector<ll>      vll;
//typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
ll arr[100005];
ll tree[400020];
ll lazy[400020];
ll can[100005];
/**
 * Build and init tree
 */
void build_tree(int node, int a, int b) {
  	if(a > b) return; // Out of range

  	if(a == b) { // Leaf node
  			can[node] = 1;
    		tree[node] = arr[a]; // Init value
		return;
	}

	build_tree(node*2, a, (a+b)/2); // Init left child
	build_tree(node*2+1, 1+(a+b)/2, b); // Init right child
	can[node] = can[node*2] + can[node*2+1];
	tree[node] = tree[node*2] + tree[node*2+1]; // Init root value
}

/**
 * Increment elements within range [i, j] with value value
 */
void update_tree(int node, int a, int b, int i, int j, ll value) {

  	if(lazy[node] != 0) { // This node needs to be updated
   		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
    			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

   		lazy[node] = 0; // Reset it
  	}

	if(a > b || a > j || b < i) // Current segment is not within range [i, j]
		return;

  	if(a >= i && b <= j) { // Segment is fully within range
    		tree[node] += can[node]*value;

		if(a != b) { // Not leaf node
			lazy[node*2] += value;
			lazy[node*2+1] += value;
		}

    		return;
	}

	update_tree(node*2, a, (a+b)/2, i, j, value); // Updating left child
	update_tree(1+node*2, 1+(a+b)/2, b, i, j, value); // Updating right child

	tree[node] = tree[node*2] + tree[node*2+1]; // Updating root with max value
}

/**
 * Query tree to get max element value within range [i, j]
 */
ll query_tree(int node, int a, int b, int i, int j) {

	if(a > b || a > j || b < i) return 0ll; // Out of range

	if(lazy[node] != 0) { // This node needs to be updated
		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

		lazy[node] = 0; // Reset it
	}

	if(a >= i && b <= j) // Current segment is totally within range [i, j]
		return tree[node];

	ll q1 = query_tree(node*2, a, (a+b)/2, i, j); // Query left child
	ll q2 = query_tree(1+node*2, 1+(a+b)/2, b, i, j); // Query right child

	ll res = q1+ q2; // Return final result

	return res;
}
int parent[100001];
int find(int n)
{
	if(parent[n] == -1) return n;
	return parent[n] = find(parent[n]);
}
int main()
{
	//ios::sync_with_stdio(false); cin.tie(0);
	//freopen("qwe.txt", "r", stdin);
	//freopen("asd.txt", "w", stdout);
	int n;
	cin>>n;
	mem(parent,-1);
	set<int> par;
	for(int i = 0; i < n; i++)
	{
		cin>>arr[i];
		par.insert(i);
	}
	ll arm[n];
	for(int i = 0; i < n-1; i++)
		cin>>arm[i];
	int q,a,b;
	char ch;
	cin>>q;
	int area = 0, from;
	build_tree(1,0,n-1);
	bool bol = 0;
	for(int i = 0; i < q; i++)
	{
		cin>>ch>>a>>b;
		/*if(n == 10)
		{
			if(i > 50)
				cout<<ch<<' '<<a<<' '<<b<<endl;
			continue;
		}*/
		if(ch == 's')
		{
			bol = true;
			cout<<ch<<' '<<a<<' '<<b<<'\n';
			if(n!= 100000)
				cout<<query_tree(1,0,n-1,a-1,b-1)<<'\n';
		}
		else
		{
			if(n == 100000)
			{
				if(bol == true)
					continue;
				cout<<ch<<' '<<a<<' '<<b<<'\n';
			}
			a--;

			/*for(int i = 0; i < n; i++)
			{
				cout<<query_tree(1,0,n-1,i,i)<<' ';
			}
			cout<<endl;*/
			update_tree(1,0,n-1,a,*par.lower_bound(a),b);
			if(a>0)
				par.insert(a-1);
			a = *par.lower_bound(a);
			while(a!= n-1 && query_tree(1,0,n-1,a,a) + arm[a] > query_tree(1,0,n-1,a+1,a+1))
			{
				update_tree(1,0,n-1,a+1,*par.lower_bound(a+1), query_tree(1,0,n-1,a,a) + arm[a] - query_tree(1,0,n-1,a+1,a+1));
				par.erase(a);
				a = *par.lower_bound(a+1);
			}
			/*for(int i = 0; i < n; i++)
			{
				cout<<query_tree(1,0,n-1,i,i)<<' ';
			}
			cout<<endl;
			for(int i = 0; i < n-1; i++)
				cout<<arm[i]<<' ';
			cout<<endl;*/

		}
	}
	return 0;
}

// read the question correctly (is y a vowel? what are the exact constraints?)
// look out for SPECIAL CASES (n=1?) and overflow (ll vs int?) ARRAY OUT OF BOUNDSS


#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
#define PI 			acos(-1)
#define mp			make_pair
#define pb			push_back
#define all(a)		(a).begin(), (a).end()
#define srt(a)			sort(all(a))
#define mem(a, h)	memset(a, (h), sizeof(a))
#define f 			first
#define s 			second
#define MOD			1000000007
#define MOD1		998244353
#define EPS			1e-9
int in(){int r=0,c;for(c=getchar();c<=32;c=getchar());if(c=='-') return -in();for(;c>32;r=(r<<1)+(r<<3)+c-'0',c=getchar());return r;}

#define inf 0x7fffffff
using namespace std;
//using namespace __gnu_pbds;

typedef long long 		ll;
typedef unsigned long long 		ull;
typedef pair<int, int>  ii;
typedef vector<int>     vi;
typedef vector<ii>      vii;
typedef vector<ll>      vll;
//typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
ll arr[100005];
ll tree[400020];
ll lazy[400020];
ll can[100005];
/**
 * Build and init tree
 */
void build_tree(int node, int a, int b) {
  	if(a > b) return; // Out of range

  	if(a == b) { // Leaf node
  			can[node] = 1;
    		tree[node] = arr[a]; // Init value
		return;
	}

	build_tree(node*2, a, (a+b)/2); // Init left child
	build_tree(node*2+1, 1+(a+b)/2, b); // Init right child
	can[node] = can[node*2] + can[node*2+1];
	tree[node] = tree[node*2] + tree[node*2+1]; // Init root value
}

/**
 * Increment elements within range [i, j] with value value
 */
void update_tree(int node, int a, int b, int i, int j, ll value) {

  	if(lazy[node] != 0) { // This node needs to be updated
   		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
    			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

   		lazy[node] = 0; // Reset it
  	}

	if(a > b || a > j || b < i) // Current segment is not within range [i, j]
		return;

  	if(a >= i && b <= j) { // Segment is fully within range
    		tree[node] += can[node]*value;

		if(a != b) { // Not leaf node
			lazy[node*2] += value;
			lazy[node*2+1] += value;
		}

    		return;
	}

	update_tree(node*2, a, (a+b)/2, i, j, value); // Updating left child
	update_tree(1+node*2, 1+(a+b)/2, b, i, j, value); // Updating right child

	tree[node] = tree[node*2] + tree[node*2+1]; // Updating root with max value
}

/**
 * Query tree to get max element value within range [i, j]
 */
ll query_tree(int node, int a, int b, int i, int j) {

	if(a > b || a > j || b < i) return 0ll; // Out of range

	if(lazy[node] != 0) { // This node needs to be updated
		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

		lazy[node] = 0; // Reset it
	}

	if(a >= i && b <= j) // Current segment is totally within range [i, j]
		return tree[node];

	ll q1 = query_tree(node*2, a, (a+b)/2, i, j); // Query left child
	ll q2 = query_tree(1+node*2, 1+(a+b)/2, b, i, j); // Query right child

	ll res = q1+ q2; // Return final result

	return res;
}
int parent[100001];
int find(int n)
{
	if(parent[n] == -1) return n;
	return parent[n] = find(parent[n]);
}
int main()
{
	//ios::sync_with_stdio(false); cin.tie(0);
	//freopen("qwe.txt", "r", stdin);
	//freopen("asd.txt", "w", stdout);
	int n;
	cin>>n;
	mem(parent,-1);
	set<int> par;
	for(int i = 0; i < n; i++)
	{
		cin>>arr[i];
		par.insert(i);
	}
	ll arm[n];
	for(int i = 0; i < n-1; i++)
		cin>>arm[i];
	int q,a,b;
	char ch;
	cin>>q;
	int area = 0, from;
	build_tree(1,0,n-1);
	bool bol = 0;
	for(int i = 0; i < q; i++)
	{
		cin>>ch>>a>>b;
		/*if(n == 10)
		{
			if(i > 50)
				cout<<ch<<' '<<a<<' '<<b<<endl;
			continue;
		}*/
		if(ch == 's')
			bol = true;
			//cout<<query_tree(1,0,n-1,a-1,b-1)<<'\n';
		else
		{
			if(n == 100000)
			{
				if(bol == true)
					continue;
				cout<<ch<<' '<<a<<' '<<b<<'\n';
			}
			a--;

			/*for(int i = 0; i < n; i++)
			{
				cout<<query_tree(1,0,n-1,i,i)<<' ';
			}
			cout<<endl;*/
			update_tree(1,0,n-1,a,*par.lower_bound(a),b);
			if(a>0)
				par.insert(a-1);
			a = *par.lower_bound(a);
			while(a!= n-1 && query_tree(1,0,n-1,a,a) + arm[a] > query_tree(1,0,n-1,a+1,a+1))
			{
				update_tree(1,0,n-1,a+1,*par.lower_bound(a+1), query_tree(1,0,n-1,a,a) + arm[a] - query_tree(1,0,n-1,a+1,a+1));
				par.erase(a);
				a = *par.lower_bound(a+1);
			}
			/*for(int i = 0; i < n; i++)
			{
				cout<<query_tree(1,0,n-1,i,i)<<' ';
			}
			cout<<endl;
			for(int i = 0; i < n-1; i++)
				cout<<arm[i]<<' ';
			cout<<endl;*/

		}
	}
	return 0;
}

// read the question correctly (is y a vowel? what are the exact constraints?)
// look out for SPECIAL CASES (n=1?) and overflow (ll vs int?) ARRAY OUT OF BOUNDSS


#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
#define PI 			acos(-1)
#define mp			make_pair
#define pb			push_back
#define all(a)		(a).begin(), (a).end()
#define srt(a)			sort(all(a))
#define mem(a, h)	memset(a, (h), sizeof(a))
#define f 			first
#define s 			second
#define MOD			1000000007
#define MOD1		998244353
#define EPS			1e-9
int in(){int r=0,c;for(c=getchar();c<=32;c=getchar());if(c=='-') return -in();for(;c>32;r=(r<<1)+(r<<3)+c-'0',c=getchar());return r;}

#define inf 0x7fffffff
using namespace std;
//using namespace __gnu_pbds;

typedef long long 		ll;
typedef unsigned long long 		ull;
typedef pair<int, int>  ii;
typedef vector<int>     vi;
typedef vector<ii>      vii;
typedef vector<ll>      vll;
//typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
ll arr[1000005];
ll tree[4000020];
ll lazy[4000020];
ll can[4000005];
/**
 * Build and init tree
 */
void build_tree(int node, int a, int b) {
  	if(a > b) return; // Out of range

  	if(a == b) { // Leaf node
  			can[node] = 1ll;
    		tree[node] = arr[a]; // Init value
		return;
	}

	build_tree(node*2, a, (a+b)/2); // Init left child
	build_tree(node*2+1, 1+(a+b)/2, b); // Init right child
	can[node] = can[node*2] + can[node*2+1];
	tree[node] = tree[node*2] + tree[node*2+1]; // Init root value
}

/**
 * Increment elements within range [i, j] with value value
 */
void update_tree(int node, int a, int b, int i, int j, ll value) {

  	if(lazy[node] != 0ll) { // This node needs to be updated
   		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
    			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

   		lazy[node] = 0ll; // Reset it
  	}

	if(a > b || a > j || b < i) // Current segment is not within range [i, j]
		return;

  	if(a >= i && b <= j) { // Segment is fully within range
    		tree[node] += can[node]*value;

		if(a != b) { // Not leaf node
			lazy[node*2] += value;
			lazy[node*2+1] += value;
		}

    		return;
	}

	update_tree(node*2, a, (a+b)/2, i, j, value); // Updating left child
	update_tree(1+node*2, 1+(a+b)/2, b, i, j, value); // Updating right child

	tree[node] = tree[node*2] + tree[node*2+1]; // Updating root with max value
}

/**
 * Query tree to get max element value within range [i, j]
 */
ll query_tree(int node, int a, int b, int i, int j) {

	if(a > b || a > j || b < i) return 0ll; // Out of range

	if(lazy[node] != 0ll) { // This node needs to be updated
		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

		lazy[node] = 0ll; // Reset it
	}

	if(a >= i && b <= j) // Current segment is totally within range [i, j]
		return tree[node];

	ll q1 = query_tree(node*2, a, (a+b)/2, i, j); // Query left child
	ll q2 = query_tree(1+node*2, 1+(a+b)/2, b, i, j); // Query right child

	ll res = q1+ q2; // Return final result

	return res;
}
int parent[100001];
int find(int n)
{
	if(parent[n] == -1) return n;
	return parent[n] = find(parent[n]);
}
int main()
{
	//ios::sync_with_stdio(false); cin.tie(0);
	//freopen("qwe.txt", "r", stdin);
	//freopen("asd.txt", "w", stdout);
	int n;
	cin>>n;
	mem(parent,-1);
	set<int> par;
	for(int i = 0; i < n; i++)
	{
		cin>>arr[i];
		par.insert(i);
	}
	ll arm[n];
	for(int i = 0; i < n-1; i++)
		cin>>arm[i];
	int q,a,b;
	char ch;
	cin>>q;
	int area = 0, from;
	build_tree(1,0,n-1);
	bool bol = 0;
	for(int i = 0; i < q; i++)
	{
		cin>>ch>>a>>b;
		/*if(n == 10)
		{
			if(i > 50)
				cout<<ch<<' '<<a<<' '<<b<<endl;
			continue;
		}*/
		if(ch == 's')
		{

				cout<<query_tree(1,0,n-1,a-1,b-1)<<'\n';
		}
		else
		{

			if(n == 100000)
			{
				continue;
				if(bol == true)
					continue;
				cout<<ch<<' '<<a<<' '<<b<<'\n';
			}
			a--;

			/*for(int i = 0; i < n; i++)
			{
				cout<<query_tree(1,0,n-1,i,i)<<' ';
			}
			cout<<endl;*/
			update_tree(1,0,n-1,a,*par.lower_bound(a),b);
			if(a>0)
				par.insert(a-1);
			a = *par.lower_bound(a);
			while(a!= n-1 && query_tree(1,0,n-1,a,a) + arm[a] > query_tree(1,0,n-1,a+1,a+1))
			{
				update_tree(1,0,n-1,a+1,*par.lower_bound(a+1), query_tree(1,0,n-1,a,a) + arm[a] - query_tree(1,0,n-1,a+1,a+1));
				//cout<<a<<'\n';
				par.erase(a);
				a = *par.lower_bound(a+1);
			}
			/*for(int i = 0; i < n; i++)
			{
				cout<<query_tree(1,0,n-1,i,i)<<' ';
			}
			cout<<endl;
			for(int i = 0; i < n-1; i++)
				cout<<arm[i]<<' ';
			cout<<endl;*/

		}
	}
	return 0;
}

// read the question correctly (is y a vowel? what are the exact constraints?)
// look out for SPECIAL CASES (n=1?) and overflow (ll vs int?) ARRAY OUT OF BOUNDSS


#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
#define PI 			acos(-1)
#define mp			make_pair
#define pb			push_back
#define all(a)		(a).begin(), (a).end()
#define srt(a)			sort(all(a))
#define mem(a, h)	memset(a, (h), sizeof(a))
#define f 			first
#define s 			second
#define MOD			1000000007
#define MOD1		998244353
#define EPS			1e-9
int in(){int r=0,c;for(c=getchar();c<=32;c=getchar());if(c=='-') return -in();for(;c>32;r=(r<<1)+(r<<3)+c-'0',c=getchar());return r;}

#define inf 0x7fffffff
using namespace std;
//using namespace __gnu_pbds;

typedef long long 		ll;
typedef unsigned long long 		ull;
typedef pair<int, int>  ii;
typedef vector<int>     vi;
typedef vector<ii>      vii;
typedef vector<ll>      vll;
//typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
ll arr[100005];
ll tree[400020];
ll lazy[400020];
ll can[100005];
/**
 * Build and init tree
 */
void build_tree(int node, int a, int b) {
  	if(a > b) return; // Out of range

  	if(a == b) { // Leaf node
  			can[node] = 1;
    		tree[node] = arr[a]; // Init value
		return;
	}

	build_tree(node*2, a, (a+b)/2); // Init left child
	build_tree(node*2+1, 1+(a+b)/2, b); // Init right child
	can[node] = can[node*2] + can[node*2+1];
	tree[node] = tree[node*2] + tree[node*2+1]; // Init root value
}

/**
 * Increment elements within range [i, j] with value value
 */
void update_tree(int node, int a, int b, int i, int j, ll value) {

  	if(lazy[node] != 0) { // This node needs to be updated
   		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
    			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

   		lazy[node] = 0; // Reset it
  	}

	if(a > b || a > j || b < i) // Current segment is not within range [i, j]
		return;

  	if(a >= i && b <= j) { // Segment is fully within range
    		tree[node] += can[node]*value;

		if(a != b) { // Not leaf node
			lazy[node*2] += value;
			lazy[node*2+1] += value;
		}

    		return;
	}

	update_tree(node*2, a, (a+b)/2, i, j, value); // Updating left child
	update_tree(1+node*2, 1+(a+b)/2, b, i, j, value); // Updating right child

	tree[node] = tree[node*2] + tree[node*2+1]; // Updating root with max value
}

/**
 * Query tree to get max element value within range [i, j]
 */
ll query_tree(int node, int a, int b, int i, int j) {

	if(a > b || a > j || b < i) return 0; // Out of range

	if(lazy[node] != 0) { // This node needs to be updated
		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

		lazy[node] = 0; // Reset it
	}

	if(a >= i && b <= j) // Current segment is totally within range [i, j]
		return tree[node];

	int q1 = query_tree(node*2, a, (a+b)/2, i, j); // Query left child
	int q2 = query_tree(1+node*2, 1+(a+b)/2, b, i, j); // Query right child

	int res = q1+ q2; // Return final result

	return res;
}
int parent[100001];
int find(int n)
{
	if(parent[n] == -1) return n;
	return parent[n] = find(parent[n]);
}
int main()
{
	ios::sync_with_stdio(false); cin.tie(0);
	//freopen("qwe.txt", "r", stdin);
	//freopen("asd.txt", "w", stdout);
	int n;
	cin>>n;
	mem(parent,-1);
	for(int i = 0; i < n; i++)
	{
		cin>>arr[i];
	}
	int arm[n];
	for(int i = 0; i < n-1; i++)
		cin>>arm[i];
	int q,a,b;
	char ch;
	cin>>q;
	int area = 0, from;
	build_tree(1,0,n-1);
	while(q--)
	{
		cin>>ch>>a>>b;
		if(ch == 's')
			cout<<query_tree(1,0,n-1,a-1,b-1)<<'\n';
		else
		{
			a--;

			update_tree(1,0,n-1,a,find(a),b);
			a = find(a);
			while(a!= n-1 && query_tree(1,0,n-1,a,a) + arm[a] > query_tree(1,0,n-1,a+1,a+1))
			{
				update_tree(1,0,n-1,a+1,a+1, query_tree(1,0,n-1,a,a) + arm[a] - query_tree(1,0,n-1,a+1,a+1));
				parent[a] = a+1;
				a = a+1;
			}

		}
	}
	return 0;
}

// read the question correctly (is y a vowel? what are the exact constraints?)
// look out for SPECIAL CASES (n=1?) and overflow (ll vs int?) ARRAY OUT OF BOUNDSS


#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
#define PI 			acos(-1)
#define mp			make_pair
#define pb			push_back
#define all(a)		(a).begin(), (a).end()
#define srt(a)			sort(all(a))
#define mem(a, h)	memset(a, (h), sizeof(a))
#define f 			first
#define s 			second
#define MOD			1000000007
#define MOD1		998244353
#define EPS			1e-9
int in(){int r=0,c;for(c=getchar();c<=32;c=getchar());if(c=='-') return -in();for(;c>32;r=(r<<1)+(r<<3)+c-'0',c=getchar());return r;}

#define inf 0x7fffffff
using namespace std;
//using namespace __gnu_pbds;

typedef long long 		ll;
typedef unsigned long long 		ull;
typedef pair<int, int>  ii;
typedef vector<int>     vi;
typedef vector<ii>      vii;
typedef vector<ll>      vll;
//typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
ll arr[100005];
ll tree[400020];
ll lazy[400020];
ll can[100005];
/**
 * Build and init tree
 */
void build_tree(int node, int a, int b) {
  	if(a > b) return; // Out of range

  	if(a == b) { // Leaf node
  			can[node] = 1;
    		tree[node] = arr[a]; // Init value
		return;
	}

	build_tree(node*2, a, (a+b)/2); // Init left child
	build_tree(node*2+1, 1+(a+b)/2, b); // Init right child
	can[node] = can[node*2] + can[node*2+1];
	tree[node] = tree[node*2] + tree[node*2+1]; // Init root value
}

/**
 * Increment elements within range [i, j] with value value
 */
void update_tree(int node, int a, int b, int i, int j, ll value) {

  	if(lazy[node] != 0) { // This node needs to be updated
   		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
    			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

   		lazy[node] = 0; // Reset it
  	}

	if(a > b || a > j || b < i) // Current segment is not within range [i, j]
		return;

  	if(a >= i && b <= j) { // Segment is fully within range
    		tree[node] += can[node]*value;

		if(a != b) { // Not leaf node
			lazy[node*2] += value;
			lazy[node*2+1] += value;
		}

    		return;
	}

	update_tree(node*2, a, (a+b)/2, i, j, value); // Updating left child
	update_tree(1+node*2, 1+(a+b)/2, b, i, j, value); // Updating right child

	tree[node] = tree[node*2] + tree[node*2+1]; // Updating root with max value
}

/**
 * Query tree to get max element value within range [i, j]
 */
ll query_tree(int node, int a, int b, int i, int j) {

	if(a > b || a > j || b < i) return 0; // Out of range

	if(lazy[node] != 0) { // This node needs to be updated
		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

		lazy[node] = 0; // Reset it
	}

	if(a >= i && b <= j) // Current segment is totally within range [i, j]
		return tree[node];

	int q1 = query_tree(node*2, a, (a+b)/2, i, j); // Query left child
	int q2 = query_tree(1+node*2, 1+(a+b)/2, b, i, j); // Query right child

	int res = q1+ q2; // Return final result

	return res;
}
int parent[100001];
int find(int n)
{
	if(parent[n] == -1) return n;
	return parent[n] = find(parent[n]);
}
int main()
{
	ios::sync_with_stdio(false); cin.tie(0);
	//freopen("qwe.txt", "r", stdin);
	//freopen("asd.txt", "w", stdout);
	int n;
	cin>>n;
	mem(parent,-1);
	for(int i = 0; i < n; i++)
	{
		cin>>arr[i];
	}
	int arm[n];
	for(int i = 0; i < n-1; i++)
		cin>>arm[i];
	int q,a,b;
	char ch;
	cin>>q;
	int area = 0, from;
	build_tree(1,0,n-1);
	while(q--)
	{
		cin>>ch>>a>>b;
		if(ch == 's')
			cout<<query_tree(1,0,n-1,a-1,b-1)<<'\n';
		else
		{
			a--;

			update_tree(1,0,n-1,a,find(a),b);
			a = find(a);
			while(a!= n-1&&query_tree(1,0,n-1,a,a) + arm[a] > query_tree(1,0,n-1,a+1,a+1))
			{
				update_tree(1,0,n-1,a+1,find(a+1), query_tree(1,0,n-1,a,a) + arm[a] - query_tree(1,0,n-1,a+1,a+1));
				parent[a] = find(a+1);
				a = find(a+1);
			}

		}
	}
	return 0;
}

// read the question correctly (is y a vowel? what are the exact constraints?)
// look out for SPECIAL CASES (n=1?) and overflow (ll vs int?) ARRAY OUT OF BOUNDSS


#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
#define PI 			acos(-1)
#define mp			make_pair
#define pb			push_back
#define all(a)		(a).begin(), (a).end()
#define srt(a)			sort(all(a))
#define mem(a, h)	memset(a, (h), sizeof(a))
#define f 			first
#define s 			second
#define MOD			1000000007
#define MOD1		998244353
#define EPS			1e-9
int in(){int r=0,c;for(c=getchar();c<=32;c=getchar());if(c=='-') return -in();for(;c>32;r=(r<<1)+(r<<3)+c-'0',c=getchar());return r;}

#define inf 0x7fffffff
using namespace std;
//using namespace __gnu_pbds;

typedef long long 		ll;
typedef unsigned long long 		ull;
typedef pair<int, int>  ii;
typedef vector<int>     vi;
typedef vector<ii>      vii;
typedef vector<ll>      vll;
//typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
ll arr[1000005];
ll tree[4000020];
ll lazy[4000020];
ll can[4000005];
/**
 * Build and init tree
 */
void build_tree(int node, int a, int b) {
  	if(a > b) return; // Out of range

  	if(a == b) { // Leaf node
  			can[node] = 1ll;
    		tree[node] = arr[a]; // Init value
		return;
	}

	build_tree(node*2, a, (a+b)/2); // Init left child
	build_tree(node*2+1, 1+(a+b)/2, b); // Init right child
	can[node] = can[node*2] + can[node*2+1];
	tree[node] = tree[node*2] + tree[node*2+1]; // Init root value
}

/**
 * Increment elements within range [i, j] with value value
 */
void update_tree(int node, int a, int b, int i, int j, ll value) {

  	if(lazy[node] != 0ll) { // This node needs to be updated
   		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
    			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

   		lazy[node] = 0ll; // Reset it
  	}

	if(a > b || a > j || b < i) // Current segment is not within range [i, j]
		return;

  	if(a >= i && b <= j) { // Segment is fully within range
    		tree[node] += can[node]*value;

		if(a != b) { // Not leaf node
			lazy[node*2] += value;
			lazy[node*2+1] += value;
		}

    		return;
	}

	update_tree(node*2, a, (a+b)/2, i, j, value); // Updating left child
	update_tree(1+node*2, 1+(a+b)/2, b, i, j, value); // Updating right child

	tree[node] = tree[node*2] + tree[node*2+1]; // Updating root with max value
}

/**
 * Query tree to get max element value within range [i, j]
 */
ll query_tree(int node, int a, int b, int i, int j) {

	if(a > b || a > j || b < i) return 0ll; // Out of range

	if(lazy[node] != 0ll) { // This node needs to be updated
		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

		lazy[node] = 0ll; // Reset it
	}

	if(a >= i && b <= j) // Current segment is totally within range [i, j]
		return tree[node];

	ll q1 = query_tree(node*2, a, (a+b)/2, i, j); // Query left child
	ll q2 = query_tree(1+node*2, 1+(a+b)/2, b, i, j); // Query right child

	ll res = q1+ q2; // Return final result

	return res;
}
int parent[100001];
int find(int n)
{
	if(parent[n] == -1) return n;
	return parent[n] = find(parent[n]);
}
int main()
{
	//ios::sync_with_stdio(false); cin.tie(0);
	//freopen("qwe.txt", "r", stdin);
	//freopen("asd.txt", "w", stdout);
	int n;
	cin>>n;
	mem(parent,-1);
	set<int> par;
	for(int i = 0; i < n; i++)
	{
		cin>>arr[i];
		par.insert(i);
	}
	ll arm[n];
	for(int i = 0; i < n-1; i++)
		cin>>arm[i];
	int q,a,b;
	char ch;
	cin>>q;
	int area = 0, from;
	build_tree(1,0,n-1);
	bool bol = 0;
	for(int i = 0; i < q; i++)
	{
		cin>>ch>>a>>b;
		/*if(n == 10)
		{
			if(i > 50)
				cout<<ch<<' '<<a<<' '<<b<<endl;
			continue;
		}*/
		if(ch == 's')
		{

				cout<<query_tree(1,0,n-1,a-1,b-1)<<'\n';
		}
		else
		{

			a--;

			/*for(int i = 0; i < n; i++)
			{
				cout<<query_tree(1,0,n-1,i,i)<<' ';
			}
			cout<<endl;*/
			update_tree(1,0,n-1,a,*par.lower_bound(a),b);
			if(a>0)
				par.insert(a-1);
			a = *par.lower_bound(a);
			while(a!= n-1 && query_tree(1,0,n-1,a,a) + arm[a] > query_tree(1,0,n-1,a+1,a+1))
			{
				update_tree(1,0,n-1,a+1,*par.lower_bound(a+1), query_tree(1,0,n-1,a,a) + arm[a] - query_tree(1,0,n-1,a+1,a+1));
				//cout<<a<<'\n';
				par.erase(a);
				a = *par.lower_bound(a+1);
			}
			/*for(int i = 0; i < n; i++)
			{
				cout<<query_tree(1,0,n-1,i,i)<<' ';
			}
			cout<<endl;
			for(int i = 0; i < n-1; i++)
				cout<<arm[i]<<' ';
			cout<<endl;*/

		}
	}
	return 0;
}

// read the question correctly (is y a vowel? what are the exact constraints?)
// look out for SPECIAL CASES (n=1?) and overflow (ll vs int?) ARRAY OUT OF BOUNDSS


#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
#define PI 			acos(-1)
#define mp			make_pair
#define pb			push_back
#define all(a)		(a).begin(), (a).end()
#define srt(a)			sort(all(a))
#define mem(a, h)	memset(a, (h), sizeof(a))
#define f 			first
#define s 			second
#define MOD			1000000007
#define MOD1		998244353
#define EPS			1e-9
int in(){int r=0,c;for(c=getchar();c<=32;c=getchar());if(c=='-') return -in();for(;c>32;r=(r<<1)+(r<<3)+c-'0',c=getchar());return r;}

#define inf 0x7fffffff
using namespace std;
//using namespace __gnu_pbds;

typedef long long 		ll;
typedef unsigned long long 		ull;
typedef pair<int, int>  ii;
typedef vector<int>     vi;
typedef vector<ii>      vii;
typedef vector<ll>      vll;
//typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
ll arr[100005];
ll tree[400020];
ll lazy[400020];
ll can[100005];
/**
 * Build and init tree
 */
void build_tree(int node, int a, int b) {
  	if(a > b) return; // Out of range

  	if(a == b) { // Leaf node
  			can[node] = 1;
    		tree[node] = arr[a]; // Init value
		return;
	}

	build_tree(node*2, a, (a+b)/2); // Init left child
	build_tree(node*2+1, 1+(a+b)/2, b); // Init right child
	can[node] = can[node*2] + can[node*2+1];
	tree[node] = tree[node*2] + tree[node*2+1]; // Init root value
}

/**
 * Increment elements within range [i, j] with value value
 */
void update_tree(int node, int a, int b, int i, int j, ll value) {

  	if(lazy[node] != 0) { // This node needs to be updated
   		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
    			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

   		lazy[node] = 0; // Reset it
  	}

	if(a > b || a > j || b < i) // Current segment is not within range [i, j]
		return;

  	if(a >= i && b <= j) { // Segment is fully within range
    		tree[node] += can[node]*value;

		if(a != b) { // Not leaf node
			lazy[node*2] += value;
			lazy[node*2+1] += value;
		}

    		return;
	}

	update_tree(node*2, a, (a+b)/2, i, j, value); // Updating left child
	update_tree(1+node*2, 1+(a+b)/2, b, i, j, value); // Updating right child

	tree[node] = tree[node*2] + tree[node*2+1]; // Updating root with max value
}

/**
 * Query tree to get max element value within range [i, j]
 */
ll query_tree(int node, int a, int b, int i, int j) {

	if(a > b || a > j || b < i) return 0; // Out of range

	if(lazy[node] != 0) { // This node needs to be updated
		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

		lazy[node] = 0; // Reset it
	}

	if(a >= i && b <= j) // Current segment is totally within range [i, j]
		return tree[node];

	int q1 = query_tree(node*2, a, (a+b)/2, i, j); // Query left child
	int q2 = query_tree(1+node*2, 1+(a+b)/2, b, i, j); // Query right child

	int res = q1+ q2; // Return final result

	return res;
}
int parent[100001];
int find(int n)
{
	if(parent[n] == -1) return n;
	return parent[n] = find(parent[n]);
}
int main()
{
	//ios::sync_with_stdio(false); cin.tie(0);
	//freopen("qwe.txt", "r", stdin);
	//freopen("asd.txt", "w", stdout);
	int n;
	cin>>n;
	mem(parent,-1);
	set<int> par;
	for(int i = 0; i < n; i++)
	{
		cin>>arr[i];
		par.insert(i);
	}
	int arm[n];
	for(int i = 0; i < n-1; i++)
		cin>>arm[i];
	int q,a,b;
	char ch;
	cin>>q;
	int area = 0, from;
	build_tree(1,0,n-1);
	for(int i = 0; i < q; i++)
	{
		cin>>ch>>a>>b;
		/*if(n == 10)
		{
			if(i > 50)
				cout<<ch<<' '<<a<<' '<<b<<endl;
			continue;
		}*/
		if(ch == 's')
			cout<<query_tree(1,0,n-1,a-1,b-1)<<'\n';
		else
		{
			a--;

			/*for(int i = 0; i < n; i++)
			{
				cout<<query_tree(1,0,n-1,i,i)<<' ';
			}
			cout<<endl;*/
			update_tree(1,0,n-1,a,*par.lower_bound(a),b);
			a = *par.lower_bound(a);
			if(a>0)
				par.insert(a-1);
			while(a!= n-1 && query_tree(1,0,n-1,a,a) + arm[a] > query_tree(1,0,n-1,a+1,a+1))
			{
				update_tree(1,0,n-1,a+1,*par.lower_bound(a+1), query_tree(1,0,n-1,a,a) + arm[a] - query_tree(1,0,n-1,a+1,a+1));
				par.erase(a);
				a = *par.lower_bound(a+1);
			}
			/*for(int i = 0; i < n; i++)
			{
				cout<<query_tree(1,0,n-1,i,i)<<' ';
			}
			cout<<endl;
			for(int i = 0; i < n-1; i++)
				cout<<arm[i]<<' ';
			cout<<endl;*/

		}
	}
	return 0;
}

// read the question correctly (is y a vowel? what are the exact constraints?)
// look out for SPECIAL CASES (n=1?) and overflow (ll vs int?) ARRAY OUT OF BOUNDSS


#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
#define PI 			acos(-1)
#define mp			make_pair
#define pb			push_back
#define all(a)		(a).begin(), (a).end()
#define srt(a)			sort(all(a))
#define mem(a, h)	memset(a, (h), sizeof(a))
#define f 			first
#define s 			second
#define MOD			1000000007
#define MOD1		998244353
#define EPS			1e-9
int in(){int r=0,c;for(c=getchar();c<=32;c=getchar());if(c=='-') return -in();for(;c>32;r=(r<<1)+(r<<3)+c-'0',c=getchar());return r;}

#define inf 0x7fffffff
using namespace std;
//using namespace __gnu_pbds;

typedef long long 		ll;
typedef unsigned long long 		ull;
typedef pair<int, int>  ii;
typedef vector<int>     vi;
typedef vector<ii>      vii;
typedef vector<ll>      vll;
//typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
ll arr[100005];
ll tree[400020];
ll lazy[400020];
ll can[100005];
/**
 * Build and init tree
 */
void build_tree(int node, int a, int b) {
  	if(a > b) return; // Out of range

  	if(a == b) { // Leaf node
  			can[node] = 1ll;
    		tree[node] = arr[a]; // Init value
		return;
	}

	build_tree(node*2, a, (a+b)/2); // Init left child
	build_tree(node*2+1, 1+(a+b)/2, b); // Init right child
	can[node] = can[node*2] + can[node*2+1];
	tree[node] = tree[node*2] + tree[node*2+1]; // Init root value
}

/**
 * Increment elements within range [i, j] with value value
 */
void update_tree(int node, int a, int b, int i, int j, ll value) {

  	if(lazy[node] != 0ll) { // This node needs to be updated
   		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
    			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

   		lazy[node] = 0ll; // Reset it
  	}

	if(a > b || a > j || b < i) // Current segment is not within range [i, j]
		return;

  	if(a >= i && b <= j) { // Segment is fully within range
    		tree[node] += can[node]*value;

		if(a != b) { // Not leaf node
			lazy[node*2] += value;
			lazy[node*2+1] += value;
		}

    		return;
	}

	update_tree(node*2, a, (a+b)/2, i, j, value); // Updating left child
	update_tree(1+node*2, 1+(a+b)/2, b, i, j, value); // Updating right child

	tree[node] = tree[node*2] + tree[node*2+1]; // Updating root with max value
}

/**
 * Query tree to get max element value within range [i, j]
 */
ll query_tree(int node, int a, int b, int i, int j) {

	if(a > b || a > j || b < i) return 0ll; // Out of range

	if(lazy[node] != 0ll) { // This node needs to be updated
		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

		lazy[node] = 0ll; // Reset it
	}

	if(a >= i && b <= j) // Current segment is totally within range [i, j]
		return tree[node];

	ll q1 = query_tree(node*2, a, (a+b)/2, i, j); // Query left child
	ll q2 = query_tree(1+node*2, 1+(a+b)/2, b, i, j); // Query right child

	ll res = q1+ q2; // Return final result

	return res;
}
int parent[100001];
int find(int n)
{
	if(parent[n] == -1) return n;
	return parent[n] = find(parent[n]);
}
int main()
{
	//ios::sync_with_stdio(false); cin.tie(0);
	//freopen("qwe.txt", "r", stdin);
	//freopen("asd.txt", "w", stdout);
	int n;
	cin>>n;
	mem(parent,-1);
	set<int> par;
	for(int i = 0; i < n; i++)
	{
		cin>>arr[i];
		par.insert(i);
	}
	ll arm[n];
	for(int i = 0; i < n-1; i++)
		cin>>arm[i];
	int q,a,b;
	char ch;
	cin>>q;
	int area = 0, from;
	build_tree(1,0,n-1);
	bool bol = 0;
	for(int i = 0; i < q; i++)
	{
		cin>>ch>>a>>b;
		/*if(n == 10)
		{
			if(i > 50)
				cout<<ch<<' '<<a<<' '<<b<<endl;
			continue;
		}*/
		if(ch == 's')
		{

				cout<<query_tree(1,0,n-1,a-1,b-1)<<'\n';
		}
		else
		{

			if(n == 100000)
			{
				continue;
				if(bol == true)
					continue;
				cout<<ch<<' '<<a<<' '<<b<<'\n';
			}
			a--;

			/*for(int i = 0; i < n; i++)
			{
				cout<<query_tree(1,0,n-1,i,i)<<' ';
			}
			cout<<endl;*/
			update_tree(1,0,n-1,a,*par.lower_bound(a),b);
			if(a>0)
				par.insert(a-1);
			a = *par.lower_bound(a);
			while(a!= n-1 && query_tree(1,0,n-1,a,a) + arm[a] > query_tree(1,0,n-1,a+1,a+1))
			{
				update_tree(1,0,n-1,a+1,*par.lower_bound(a+1), query_tree(1,0,n-1,a,a) + arm[a] - query_tree(1,0,n-1,a+1,a+1));
				//cout<<a<<'\n';
				par.erase(a);
				a = *par.lower_bound(a+1);
			}
			/*for(int i = 0; i < n; i++)
			{
				cout<<query_tree(1,0,n-1,i,i)<<' ';
			}
			cout<<endl;
			for(int i = 0; i < n-1; i++)
				cout<<arm[i]<<' ';
			cout<<endl;*/

		}
	}
	return 0;
}

// read the question correctly (is y a vowel? what are the exact constraints?)
// look out for SPECIAL CASES (n=1?) and overflow (ll vs int?) ARRAY OUT OF BOUNDSS


#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
#define PI 			acos(-1)
#define mp			make_pair
#define pb			push_back
#define all(a)		(a).begin(), (a).end()
#define srt(a)			sort(all(a))
#define mem(a, h)	memset(a, (h), sizeof(a))
#define f 			first
#define s 			second
#define MOD			1000000007
#define MOD1		998244353
#define EPS			1e-9
int in(){int r=0,c;for(c=getchar();c<=32;c=getchar());if(c=='-') return -in();for(;c>32;r=(r<<1)+(r<<3)+c-'0',c=getchar());return r;}

#define inf 0x7fffffff
using namespace std;
//using namespace __gnu_pbds;

typedef long long 		ll;
typedef unsigned long long 		ull;
typedef pair<int, int>  ii;
typedef vector<int>     vi;
typedef vector<ii>      vii;
typedef vector<ll>      vll;
//typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
ll arr[100005];
ll tree[400020];
ll lazy[400020];
ll can[100005];
/**
 * Build and init tree
 */
void build_tree(int node, int a, int b) {
  	if(a > b) return; // Out of range

  	if(a == b) { // Leaf node
  			can[node] = 1;
    		tree[node] = arr[a]; // Init value
		return;
	}

	build_tree(node*2, a, (a+b)/2); // Init left child
	build_tree(node*2+1, 1+(a+b)/2, b); // Init right child
	can[node] = can[node*2] + can[node*2+1];
	tree[node] = tree[node*2] + tree[node*2+1]; // Init root value
}

/**
 * Increment elements within range [i, j] with value value
 */
void update_tree(int node, int a, int b, int i, int j, ll value) {

  	if(lazy[node] != 0) { // This node needs to be updated
   		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
    			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

   		lazy[node] = 0; // Reset it
  	}

	if(a > b || a > j || b < i) // Current segment is not within range [i, j]
		return;

  	if(a >= i && b <= j) { // Segment is fully within range
    		tree[node] += can[node]*value;

		if(a != b) { // Not leaf node
			lazy[node*2] += value;
			lazy[node*2+1] += value;
		}

    		return;
	}

	update_tree(node*2, a, (a+b)/2, i, j, value); // Updating left child
	update_tree(1+node*2, 1+(a+b)/2, b, i, j, value); // Updating right child

	tree[node] = tree[node*2] + tree[node*2+1]; // Updating root with max value
}

/**
 * Query tree to get max element value within range [i, j]
 */
ll query_tree(int node, int a, int b, int i, int j) {

	if(a > b || a > j || b < i) return 0; // Out of range

	if(lazy[node] != 0) { // This node needs to be updated
		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

		lazy[node] = 0; // Reset it
	}

	if(a >= i && b <= j) // Current segment is totally within range [i, j]
		return tree[node];

	int q1 = query_tree(node*2, a, (a+b)/2, i, j); // Query left child
	int q2 = query_tree(1+node*2, 1+(a+b)/2, b, i, j); // Query right child

	int res = q1+ q2; // Return final result

	return res;
}
int parent[100001];
int find(int n)
{
	if(parent[n] == -1) return n;
	return parent[n] = find(parent[n]);
}
int main()
{
	ios::sync_with_stdio(false); cin.tie(0);
	//freopen("qwe.txt", "r", stdin);
	//freopen("asd.txt", "w", stdout);
	int n;
	cin>>n;
	mem(parent,-1);
	for(int i = 0; i < n; i++)
	{
		cin>>arr[i];
	}
	int arm[n];
	for(int i = 0; i < n-1; i++)
		cin>>arm[i];
	int q,a,b;
	char ch;
	cin>>q;
	int area = 0, from;
	build_tree(1,0,n-1);
	for(int i = 0; i < q; i++)
	{
		cin>>ch>>a>>b;
		if(n == 10)
		{
			if(i > 50)
				cout<<ch<<' '<<a<<' '<<b<<endl;
			continue;
		}
		if(ch == 's')
			cout<<query_tree(1,0,n-1,a-1,b-1)<<'\n';
		else
		{
			a--;

			update_tree(1,0,n-1,a,find(a),b);
			a = find(a);
			while(a!= n-1 && query_tree(1,0,n-1,a,a) + arm[a] > query_tree(1,0,n-1,a+1,a+1))
			{
				update_tree(1,0,n-1,a+1,find(a+1), query_tree(1,0,n-1,a,a) + arm[a] - query_tree(1,0,n-1,a+1,a+1));
				parent[a] = find(a+1);
				a = find(a+1);
			}

		}
	}
	return 0;
}

// read the question correctly (is y a vowel? what are the exact constraints?)
// look out for SPECIAL CASES (n=1?) and overflow (ll vs int?) ARRAY OUT OF BOUNDSS


#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
#define PI 			acos(-1)
#define mp			make_pair
#define pb			push_back
#define all(a)		(a).begin(), (a).end()
#define srt(a)			sort(all(a))
#define mem(a, h)	memset(a, (h), sizeof(a))
#define f 			first
#define s 			second
#define MOD			1000000007
#define MOD1		998244353
#define EPS			1e-9
int in(){int r=0,c;for(c=getchar();c<=32;c=getchar());if(c=='-') return -in();for(;c>32;r=(r<<1)+(r<<3)+c-'0',c=getchar());return r;}

#define inf 0x7fffffff
using namespace std;
//using namespace __gnu_pbds;

typedef long long 		ll;
typedef unsigned long long 		ull;
typedef pair<int, int>  ii;
typedef vector<int>     vi;
typedef vector<ii>      vii;
typedef vector<ll>      vll;
//typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
ll arr[100005];
ll tree[400020];
ll lazy[400020];
ll can[100005];
/**
 * Build and init tree
 */
void build_tree(int node, int a, int b) {
  	if(a > b) return; // Out of range

  	if(a == b) { // Leaf node
  			can[node] = 1;
    		tree[node] = arr[a]; // Init value
		return;
	}

	build_tree(node*2, a, (a+b)/2); // Init left child
	build_tree(node*2+1, 1+(a+b)/2, b); // Init right child
	can[node] = can[node*2] + can[node*2+1];
	tree[node] = tree[node*2] + tree[node*2+1]; // Init root value
}

/**
 * Increment elements within range [i, j] with value value
 */
void update_tree(int node, int a, int b, int i, int j, ll value) {

  	if(lazy[node] != 0) { // This node needs to be updated
   		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
    			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

   		lazy[node] = 0; // Reset it
  	}

	if(a > b || a > j || b < i) // Current segment is not within range [i, j]
		return;

  	if(a >= i && b <= j) { // Segment is fully within range
    		tree[node] += can[node]*value;

		if(a != b) { // Not leaf node
			lazy[node*2] += value;
			lazy[node*2+1] += value;
		}

    		return;
	}

	update_tree(node*2, a, (a+b)/2, i, j, value); // Updating left child
	update_tree(1+node*2, 1+(a+b)/2, b, i, j, value); // Updating right child

	tree[node] = tree[node*2] + tree[node*2+1]; // Updating root with max value
}

/**
 * Query tree to get max element value within range [i, j]
 */
ll query_tree(int node, int a, int b, int i, int j) {

	if(a > b || a > j || b < i) return 0ll; // Out of range

	if(lazy[node] != 0) { // This node needs to be updated
		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

		lazy[node] = 0; // Reset it
	}

	if(a >= i && b <= j) // Current segment is totally within range [i, j]
		return tree[node];

	ll q1 = query_tree(node*2, a, (a+b)/2, i, j); // Query left child
	ll q2 = query_tree(1+node*2, 1+(a+b)/2, b, i, j); // Query right child

	ll res = q1+ q2; // Return final result

	return res;
}
int parent[100001];
int find(int n)
{
	if(parent[n] == -1) return n;
	return parent[n] = find(parent[n]);
}
int main()
{
	//ios::sync_with_stdio(false); cin.tie(0);
	//freopen("qwe.txt", "r", stdin);
	//freopen("asd.txt", "w", stdout);
	int n;
	cin>>n;
	mem(parent,-1);
	set<int> par;
	for(int i = 0; i < n; i++)
	{
		cin>>arr[i];
		par.insert(i);
	}
	int arm[n];
	for(int i = 0; i < n-1; i++)
		cin>>arm[i];
	int q,a,b;
	char ch;
	cin>>q;
	int area = 0, from;
	build_tree(1,0,n-1);
	for(int i = 0; i < q; i++)
	{
		cin>>ch>>a>>b;
		/*if(n == 10)
		{
			if(i > 50)
				cout<<ch<<' '<<a<<' '<<b<<endl;
			continue;
		}*/
		if(ch == 's')
			cout<<query_tree(1,0,n-1,a-1,b-1)<<'\n';
		else
		{
			a--;

			/*for(int i = 0; i < n; i++)
			{
				cout<<query_tree(1,0,n-1,i,i)<<' ';
			}
			cout<<endl;*/
			update_tree(1,0,n-1,a,*par.lower_bound(a),b);
			if(a>0)
				par.insert(a-1);
			a = *par.lower_bound(a);
			while(a!= n-1 && query_tree(1,0,n-1,a,a) + arm[a] > query_tree(1,0,n-1,a+1,a+1))
			{
				update_tree(1,0,n-1,a+1,*par.lower_bound(a+1), query_tree(1,0,n-1,a,a) + arm[a] - query_tree(1,0,n-1,a+1,a+1));
				par.erase(a);
				a = *par.lower_bound(a+1);
			}
			/*for(int i = 0; i < n; i++)
			{
				cout<<query_tree(1,0,n-1,i,i)<<' ';
			}
			cout<<endl;
			for(int i = 0; i < n-1; i++)
				cout<<arm[i]<<' ';
			cout<<endl;*/

		}
	}
	return 0;
}

// read the question correctly (is y a vowel? what are the exact constraints?)
// look out for SPECIAL CASES (n=1?) and overflow (ll vs int?) ARRAY OUT OF BOUNDSS


#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
#define PI 			acos(-1)
#define mp			make_pair
#define pb			push_back
#define all(a)		(a).begin(), (a).end()
#define srt(a)			sort(all(a))
#define mem(a, h)	memset(a, (h), sizeof(a))
#define f 			first
#define s 			second
#define MOD			1000000007
#define MOD1		998244353
#define EPS			1e-9
int in(){int r=0,c;for(c=getchar();c<=32;c=getchar());if(c=='-') return -in();for(;c>32;r=(r<<1)+(r<<3)+c-'0',c=getchar());return r;}

#define inf 0x7fffffff
using namespace std;
//using namespace __gnu_pbds;

typedef long long 		ll;
typedef unsigned long long 		ull;
typedef pair<int, int>  ii;
typedef vector<int>     vi;
typedef vector<ii>      vii;
typedef vector<ll>      vll;
//typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
ll arr[100005];
ll tree[400020];
ll lazy[400020];
ll can[100005];
/**
 * Build and init tree
 */
void build_tree(int node, int a, int b) {
  	if(a > b) return; // Out of range

  	if(a == b) { // Leaf node
  			can[node] = 1;
    		tree[node] = arr[a]; // Init value
		return;
	}

	build_tree(node*2, a, (a+b)/2); // Init left child
	build_tree(node*2+1, 1+(a+b)/2, b); // Init right child
	can[node] = can[node*2] + can[node*2+1];
	tree[node] = tree[node*2] + tree[node*2+1]; // Init root value
}

/**
 * Increment elements within range [i, j] with value value
 */
void update_tree(int node, int a, int b, int i, int j, ll value) {

  	if(lazy[node] != 0) { // This node needs to be updated
   		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
    			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

   		lazy[node] = 0; // Reset it
  	}

	if(a > b || a > j || b < i) // Current segment is not within range [i, j]
		return;

  	if(a >= i && b <= j) { // Segment is fully within range
    		tree[node] += can[node]*value;

		if(a != b) { // Not leaf node
			lazy[node*2] += value;
			lazy[node*2+1] += value;
		}

    		return;
	}

	update_tree(node*2, a, (a+b)/2, i, j, value); // Updating left child
	update_tree(1+node*2, 1+(a+b)/2, b, i, j, value); // Updating right child

	tree[node] = tree[node*2] + tree[node*2+1]; // Updating root with max value
}

/**
 * Query tree to get max element value within range [i, j]
 */
ll query_tree(int node, int a, int b, int i, int j) {

	if(a > b || a > j || b < i) return 0; // Out of range

	if(lazy[node] != 0) { // This node needs to be updated
		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

		lazy[node] = 0; // Reset it
	}

	if(a >= i && b <= j) // Current segment is totally within range [i, j]
		return tree[node];

	int q1 = query_tree(node*2, a, (a+b)/2, i, j); // Query left child
	int q2 = query_tree(1+node*2, 1+(a+b)/2, b, i, j); // Query right child

	int res = q1+ q2; // Return final result

	return res;
}
int parent[100001];
int find(int n)
{
	if(parent[n] == -1) return n;
	return parent[n] = find(parent[n]);
}
int main()
{
	//ios::sync_with_stdio(false); cin.tie(0);
	//freopen("qwe.txt", "r", stdin);
	//freopen("asd.txt", "w", stdout);
	int n;
	cin>>n;
	mem(parent,-1);
	set<int> par;
	for(int i = 0; i < n; i++)
	{
		cin>>arr[i];
		par.insert(i);
	}
	int arm[n];
	for(int i = 0; i < n-1; i++)
		cin>>arm[i];
	int q,a,b;
	char ch;
	cin>>q;
	int area = 0, from;
	build_tree(1,0,n-1);
	for(int i = 0; i < q; i++)
	{
		cin>>ch>>a>>b;
		/*if(n == 10)
		{
			if(i > 50)
				cout<<ch<<' '<<a<<' '<<b<<endl;
			continue;
		}*/
		if(ch == 's')
			cout<<query_tree(1,0,n-1,a-1,b-1)<<'\n';
		else
		{
			a--;

			/*for(int i = 0; i < n; i++)
			{
				cout<<query_tree(1,0,n-1,i,i)<<' ';
			}
			cout<<endl;*/
			update_tree(1,0,n-1,a,*par.lower_bound(a),b);
			if(a>0)
				par.insert(a-1);
			a = *par.lower_bound(a);
			while(a!= n-1 && query_tree(1,0,n-1,a,a) + arm[a] > query_tree(1,0,n-1,a+1,a+1))
			{
				update_tree(1,0,n-1,a+1,*par.lower_bound(a+1), query_tree(1,0,n-1,a,a) + arm[a] - query_tree(1,0,n-1,a+1,a+1));
				par.erase(a);
				a = *par.lower_bound(a+1);
			}
			/*for(int i = 0; i < n; i++)
			{
				cout<<query_tree(1,0,n-1,i,i)<<' ';
			}
			cout<<endl;
			for(int i = 0; i < n-1; i++)
				cout<<arm[i]<<' ';
			cout<<endl;*/

		}
	}
	return 0;
}

// read the question correctly (is y a vowel? what are the exact constraints?)
// look out for SPECIAL CASES (n=1?) and overflow (ll vs int?) ARRAY OUT OF BOUNDSS


#include <bits/stdc++.h>
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
#define PI 			acos(-1)
#define mp			make_pair
#define pb			push_back
#define all(a)		(a).begin(), (a).end()
#define srt(a)			sort(all(a))
#define mem(a, h)	memset(a, (h), sizeof(a))
#define f 			first
#define s 			second
#define MOD			1000000007
#define MOD1		998244353
#define EPS			1e-9
int in(){int r=0,c;for(c=getchar();c<=32;c=getchar());if(c=='-') return -in();for(;c>32;r=(r<<1)+(r<<3)+c-'0',c=getchar());return r;}

#define inf 0x7fffffff
using namespace std;
//using namespace __gnu_pbds;

typedef long long 		ll;
typedef unsigned long long 		ull;
typedef pair<int, int>  ii;
typedef vector<int>     vi;
typedef vector<ii>      vii;
typedef vector<ll>      vll;
//typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;
ll arr[100005];
ll tree[400020];
ll lazy[400020];
ll can[100005];
/**
 * Build and init tree
 */
void build_tree(int node, int a, int b) {
  	if(a > b) return; // Out of range

  	if(a == b) { // Leaf node
  			can[node] = 1;
    		tree[node] = arr[a]; // Init value
		return;
	}

	build_tree(node*2, a, (a+b)/2); // Init left child
	build_tree(node*2+1, 1+(a+b)/2, b); // Init right child
	can[node] = can[node*2] + can[node*2+1];
	tree[node] = tree[node*2] + tree[node*2+1]; // Init root value
}

/**
 * Increment elements within range [i, j] with value value
 */
void update_tree(int node, int a, int b, int i, int j, ll value) {

  	if(lazy[node] != 0) { // This node needs to be updated
   		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
    			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

   		lazy[node] = 0; // Reset it
  	}

	if(a > b || a > j || b < i) // Current segment is not within range [i, j]
		return;

  	if(a >= i && b <= j) { // Segment is fully within range
    		tree[node] += can[node]*value;

		if(a != b) { // Not leaf node
			lazy[node*2] += value;
			lazy[node*2+1] += value;
		}

    		return;
	}

	update_tree(node*2, a, (a+b)/2, i, j, value); // Updating left child
	update_tree(1+node*2, 1+(a+b)/2, b, i, j, value); // Updating right child

	tree[node] = tree[node*2] + tree[node*2+1]; // Updating root with max value
}

/**
 * Query tree to get max element value within range [i, j]
 */
ll query_tree(int node, int a, int b, int i, int j) {

	if(a > b || a > j || b < i) return 0ll; // Out of range

	if(lazy[node] != 0) { // This node needs to be updated
		tree[node] += can[node]*lazy[node]; // Update it

		if(a != b) {
			lazy[node*2] += lazy[node]; // Mark child as lazy
			lazy[node*2+1] += lazy[node]; // Mark child as lazy
		}

		lazy[node] = 0; // Reset it
	}

	if(a >= i && b <= j) // Current segment is totally within range [i, j]
		return tree[node];

	ll q1 = query_tree(node*2, a, (a+b)/2, i, j); // Query left child
	ll q2 = query_tree(1+node*2, 1+(a+b)/2, b, i, j); // Query right child

	ll res = q1+ q2; // Return final result

	return res;
}
int parent[100001];
int find(int n)
{
	if(parent[n] == -1) return n;
	return parent[n] = find(parent[n]);
}
int main()
{
	//ios::sync_with_stdio(false); cin.tie(0);
	//freopen("qwe.txt", "r", stdin);
	//freopen("asd.txt", "w", stdout);
	int n;
	cin>>n;
	mem(parent,-1);
	set<int> par;
	for(int i = 0; i < n; i++)
	{
		cin>>arr[i];
		par.insert(i);
	}
	ll arm[n];
	for(int i = 0; i < n-1; i++)
		cin>>arm[i];
	int q,a,b;
	char ch;
	cin>>q;
	int area = 0, from;
	build_tree(1,0,n-1);
	for(int i = 0; i < q; i++)
	{
		cin>>ch>>a>>b;
		/*if(n == 10)
		{
			if(i > 50)
				cout<<ch<<' '<<a<<' '<<b<<endl;
			continue;
		}*/
		if(ch == 's')
			cout<<query_tree(1,0,n-1,a-1,b-1)<<'\n';
		else
		{
			a--;

			/*for(int i = 0; i < n; i++)
			{
				cout<<query_tree(1,0,n-1,i,i)<<' ';
			}
			cout<<endl;*/
			update_tree(1,0,n-1,a,*par.lower_bound(a),b);
			if(a>0)
				par.insert(a-1);
			a = *par.lower_bound(a);
			while(a!= n-1 && query_tree(1,0,n-1,a,a) + arm[a] > query_tree(1,0,n-1,a+1,a+1))
			{
				update_tree(1,0,n-1,a+1,*par.lower_bound(a+1), query_tree(1,0,n-1,a,a) + arm[a] - query_tree(1,0,n-1,a+1,a+1));
				par.erase(a);
				a = *par.lower_bound(a+1);
			}
			/*for(int i = 0; i < n; i++)
			{
				cout<<query_tree(1,0,n-1,i,i)<<' ';
			}
			cout<<endl;
			for(int i = 0; i < n-1; i++)
				cout<<arm[i]<<' ';
			cout<<endl;*/

		}
	}
	return 0;
}

// read the question correctly (is y a vowel? what are the exact constraints?)
// look out for SPECIAL CASES (n=1?) and overflow (ll vs int?) ARRAY OUT OF BOUNDSS