Mishina_Fignya

#include <bits/stdc++.h>

using namespace std;

struct vertex {
    long long maxlen, l, r, p, lenl, lenr;
};

vector<vertex> tree;
vector<long long> a;

void dopush(long long t, long long l, long long r) {
    tree[t].l += tree[t].p;
    tree[t].r += tree[t].p;

    if (l < r - 1) {
        tree[t * 2 + 1].p += tree[t].p;
        tree[t * 2 + 2].p += tree[t].p;
    }

    tree[t].p = 0;
}

void setpush(long long t, long long l, long long r, long long a, long long b, long long x) {
    if (l >= b || r <= a) {
        return;
    }
    if (l >= a && r <= b) {
        tree[t].p += x;
        return;
    }
    long long m = (l + r) / 2;
    dopush(t, l, r);
    dopush(t * 2 + 1, l, m);
    dopush(t * 2 + 2, m, r);
    setpush(t * 2 + 1, l, m, a, b, x);
    setpush(t * 2 + 2, m, r, a, b, x);
    dopush(t * 2 + 1, l, m);
    dopush(t * 2 + 2, m, r);
    tree[t].l = tree[t * 2 + 1].l + tree[t * 2 + 1].p;
    tree[t].r = tree[t * 2 + 2].r + tree[t * 2 + 2].p;
    tree[t].lenl = tree[t * 2 + 1].lenl;
    tree[t].lenr = tree[t * 2 + 2].lenr;
    tree[t].maxlen = max(tree[t * 2 + 1].maxlen, tree[t * 2 + 2].maxlen);

    if (tree[t * 2 + 1].r + tree[t * 2 + 1].p == tree[t * 2 + 2].l + tree[t * 2 + 2].p - 1) {
        if (tree[t * 2 + 1].lenr + tree[t * 2 + 2].lenl > tree[t].maxlen) {
            tree[t].maxlen = tree[t * 2 + 1].lenr + tree[t * 2 + 2].lenl;
        }
        if (tree[t].lenl == m - l) tree[t].lenl = m - l + tree[t * 2 + 2].lenl;
        if (tree[t].lenr == r - m) tree[t].lenr = r - m + tree[t * 2 + 1].lenr;
    }
}

vertex getans(long long t, long long l, long long r, long long a, long long b) {
    if (l >= b || r <= a) {
        return {0, 0, 0, 0, 0, 0};
    }
    if (l >= a && r <= b) return tree[t];
    dopush(t, l, r);
    long long m = (l + r) / 2;
    dopush(t * 2 + 1, l, m);
    dopush(t * 2 + 2, m, r);
    vertex x = getans(t * 2 + 1, l, m, a, b);
    vertex y = getans(t * 2 + 2, m, r, a, b);
    if (x.maxlen == 0) return y;
    if (y.maxlen == 0) return x;
    vertex ans;
    ans.l = x.l + x.p;//vozmozhno oshibka
    ans.r = y.r + y.p;//
    ans.lenl = x.lenl;
    ans.lenr = y.lenr;
    ans.maxlen = max(x.maxlen, y.maxlen);

    if (x.r + x.p == y.l + y.p - 1) {
        if (x.lenr + y.lenl >= ans.maxlen) {
            ans.maxlen = x.lenr + y.lenl;
        }
        if (ans.lenl == m - l) ans.lenl = m - l + y.lenl;
        if (ans.lenr == r - m) ans.lenr = r - m + x.lenr;

    }
    return ans;
}

void build(long long t, long long l, long long r) {
    if (l == r - 1) {
        tree[t].maxlen = 1;
        tree[t].p = 0;
        tree[t].l = a[l];
        tree[t].r = a[l];
        tree[t].lenl = 1;
        tree[t].lenr = 1;
        return;
    }
    long long m = (l + r) / 2;
    build(t * 2 + 1, l, m);
    build(t * 2 + 2, m, r);
    tree[t].l = tree[t * 2 + 1].l;
    tree[t].r = tree[t * 2 + 2].r;
    tree[t].lenl = tree[t * 2 + 1].lenl;
    tree[t].lenr = tree[t * 2 + 2].lenr;
    tree[t].maxlen = max(tree[t * 2 + 1].maxlen, tree[t * 2 + 2].maxlen);

    if (tree[t * 2 + 1].r == tree[t * 2 + 2].l - 1) {
        if (tree[t * 2 + 1].lenr + tree[t * 2 + 2].lenl > tree[t].maxlen) {
            tree[t].maxlen = tree[t * 2 + 1].lenr + tree[t * 2 + 2].lenl;
        }
        if (tree[t].lenl == m - l) tree[t].lenl = m - l + tree[t * 2 + 2].lenl;
        if (tree[t].lenr == r - m) tree[t].lenr = r - m + tree[t * 2 + 1].lenr;
    }
}

void print(int t, int l, int r) {
    if (l == r - 1) {
        cout << tree[t].l + tree[t].p << " ";
        return;
    }
    print(t * 2 + 1, l, (l + r) / 2);
    print(t * 2 + 2, (l + r) / 2, r);
}

int main() {
    //freopen("atoms.in", "r", stdin);
    //freopen("atoms.out", "w", stdout);
    long long n;

    cin >> n;
    tree.resize(n * 5);
    a.resize(n);
    for (long long i = 0; i < n; ++i) {
        cin >> a[i];
    }
    build(0, 0, n);
    long long m;
    cin >> m;
    for (long long i = 0; i < m; ++i) {
        char c;
        long long l, r;
        cin >> c >> l >> r;
        --l;
        if (c == '+') {
            long long x;
            cin >> x;
            //setpush(0, 0, n, l, r, x);
        } else {
            cout << getans(0, 0, n, l, r).maxlen << endl;
        }
    }
    print(0, 0, n);
    return 0;
}