might be overkill but an implicit treap can definitely work here.

This is solvable online using a segment tree.

Problem: SPOJ GSS3

In each node you keep the max prefix sum, max suffix sum, total sum and the answer. The merge is as following:

struct Node {
  int pf_mx, sf_mx, sum, ans;

  Node merge(const Node& R) const {
    // Merge myself (left child) with R (right child)
    Node newNode;
    newNode.pf_mx = max(pf_mx, sum + R.pf_mx);
    newNode.sf_mx = max(R.sf_mx, R.sum + sf_mx);
    newNode.sum = sum + R.sum;
    newNode.ans = max({ans, R.ans, sf_mx + R.pf_mx});
    return  newNode;
  }
};

Now for each range query you need to print node.ans.

I guess that you can compute the original sum for each interval $$$[l_{i}, r_{i}]$$$ and after that, the problem reduces to adding some $$$x$$$ to all the intervals with $$$l \leq i \leq r$$$ and maintaining the maximum of those values.

You can do this in $$$O(\log^{2}{n})$$$ by using a Fenwick Tree in which each position $$$i$$$ stores the pairs $$$(r, value)$$$ of the intervals with $$$l \in [i - LSO(i) + 1]$$$ (Fenwick Tree nature) in a treap.

The operations reduce to:

void insert(int l, int r, long long value) {
   while(l <= n) {
      T[l].insert(r, value);
      l += (-l) & l;
   }
}

void update(int l, int r, long long add) {
   while(l <= n) {
      T[l].add_to_range(r, n, add);
      l += (-l) & l;
   }
}

long long get_max() {
   long long res = LLONG_MIN;
   for(int p = n; p > 0; p &= p - 1) {
      res = max(res, T[p].get_max());
   }
   return res;
}

Since once you iterate through the Fenwick Tree you have already guaranteed that $$$l \leq i$$$, you will only need to focus on updating the intervals with $$$i \leq r$$$, which can be done in $$$O(\log{n})$$$ in a treap with lazy propagation.

Since you will iterate over at most $$$O(\log{n})$$$ treaps, the queries can be solved in $$$O(\log^{2}{n})$$$.

EDIT: This idea doesn't work, but you can use SQRT decomposition to keep the intervals with $$$l$$$ inside the corresponding bucket and apply the same idea of lazy propagation for the values with $$$i \leq r$$$. This increases the query complexity to $$$O(\sqrt{n}\log{n})$$$.