#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

struct LazySegmentTree {
    int n;
    vector<long long> tree;
    vector<long long> lazy;

    LazySegmentTree(int size, const vector<long long>& values) {
        n = 1;
        while (n < size) n <<= 1;
        tree.resize(2 * n, 0);
        lazy.resize(2 * n, 0);
        for (int i = 0; i < size; ++i) tree[i + n] = values[i];
        for (int i = n - 1; i >= 1; --i) tree[i] = max(tree[2*i], tree[2*i+1]);
    }

    void apply(int node, long long value) {
        tree[node] += value;
        if (node < n) lazy[node] += value;
    }

    void push(int node) {
        if (lazy[node] == 0) return;
        apply(2*node, lazy[node]);
        apply(2*node+1, lazy[node]);
        lazy[node] = 0;
    }

    void range_add(int l, int r, long long value, int node, int node_l, int node_r) {
        if (r < node_l || l > node_r) return;
        if (l <= node_l && node_r <= r) {
            apply(node, value);
            return;
        }
        push(node);
        int mid = (node_l + node_r) / 2;
        range_add(l, r, value, 2*node, node_l, mid);
        range_add(l, r, value, 2*node+1, mid+1, node_r);
        tree[node] = max(tree[2*node], tree[2*node+1]);
    }

    void range_add(int l, int r, long long value) {
        range_add(l, r, value, 1, 0, n-1);
    }

    long long get_max() {
        return tree[1];
    }
};

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

    int N;
    cin >> N;
    vector<long long> T(N-1);
    for (int i = 0; i < N-1; ++i) {
        cin >> T[i];
    }

    int M;
    cin >> M;

    vector<long long> values(N-1);
    for (int i = 0; i < N-1; ++i) {
        values[i] = T[i] + 3LL * (N - (i+1));
    }

    LazySegmentTree lst(N-1, values);

    for (int m = 0; m < M; ++m) {
        int L, R;
        long long D;
        cin >> L >> R >> D;
        L--; R--;
        lst.range_add(L, R, D);
        cout << lst.get_max() << '\n';
    }

    return 0;
}