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

const long long INF = 1.1e17;
struct node {
  long long mx, lazy_add;
  node() {
    mx = -INF;
    lazy_add = INF;
  }
};
struct SegmentTreeLazy {
  int size = 1;
  vector<node> st;
  SegmentTreeLazy() {}
  SegmentTreeLazy(int n) { Initial(n); }
  SegmentTreeLazy(vector<int>& a) {
    Initial((int)a.size() - 1);
    Build(1, 0, size, a);
  }
  void Initial(int _n) {
    size = _n;
    int tree_size = 1;
    while (tree_size <= size) tree_size *= 2;
    st.resize(tree_size * 2);
  }
  node Make_node(long long val) {
    node res;
    res.mx = val;
    res.lazy_add = INF;
    return res;
  }
  node Merge(node& l, node& r) {
    node res;
    res.mx = max(l.mx, r.mx);
    return res;
  }
  void Push(int u, int l, int r) {
    if (st[u].lazy_add == INF) return;
    if (l != r) {
      int v = 2 * u, w = 2 * u + 1;
      if (st[v].lazy_add != INF) st[v].lazy_add += st[u].lazy_add;
      else st[v].lazy_add = st[u].lazy_add;
      if (st[w].lazy_add != INF) st[w].lazy_add += st[u].lazy_add;
      else st[w].lazy_add = st[u].lazy_add;
    }
    st[u].mx += st[u].lazy_add;
    st[u].lazy_add = INF;
  }
  void Build(int u, int s, int e, vector<int>& a) {
    if (s == e) {
      st[u] = Make_node(a[s]);
      return;
    }
    int v = 2 * u, w = 2 * u + 1, m = (s + e) / 2;
    Build(v, s, m, a);
    Build(w, m + 1, e, a);
    st[u] = Merge(st[v], st[w]);
  }
  void Update(int u, int s, int e, int l, int r, long long val) {
    Push(u, s, e);
    if (e < l || r < s) return;
    if (l <= s && e <= r) {
      if (st[u].lazy_add != INF) st[u].lazy_add += val;
      else st[u].lazy_add = val;
      Push(u, s, e);
      return;
    }
    int v = 2 * u, w = 2 * u + 1, m = (s + e) / 2;
    Update(v, s, m, l, r, val);
    Update(w, m + 1, e, l, r, val);
    st[u] = Merge(st[v], st[w]);
  }
  void Update(int l, int r, long long val) {
    Update(1, 0, size, l, r, val);
  }
  node Query(int u, int s, int e, int l, int r) {
    Push(u, s, e);
    if (e < l || r < s) {
      return node();
    }
    if (l <= s && e <= r) return st[u];
    int v = 2 * u, w = 2 * u + 1, m = (s + e) / 2;
    node lsum = Query(v, s, m, l, r);
    node rsum = Query(w, m + 1, e, l, r);
    return Merge(lsum, rsum);
  }
  node Query(int l, int r) {
    return Query(1, 0, size, l, r);
  }
};
 
void solve() {
  int n;
  cin >> n;
  vector<int> a(n + 1);
  for (int i = 1; i <= n; i++) {
    cin >> a[i];
  }
  SegmentTreeLazy sg(a);
  int q;
  cin >> q;
  while (q--) {
    int type;
    cin >> type;
    if (type == 1) {
      int l, r, x;
      cin >> l >> r >> x;
      sg.Update(l, r, x);
    } else {
      int l, r;
      cin >> l >> r;
      cout << sg.Query(l, r).mx << '\n';
    }
  }
}

int main() {
  ios_base::sync_with_stdio(0), cin.tie(0);
  int t = 1;
  cin >> t;
  for (int i = 1; i <= t; i++) {
    solve();
  }
  return 0;
}