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

#define inf 0x3f3f


struct Node {
    int maxPrefixSum;
    int maxSuffixSum;
    int totalSum;
    int maxSubarraySum;

    Node()
    {
        maxPrefixSum = maxSuffixSum = maxSubarraySum = -inf;
        totalSum = -inf;
    }
};

Node merge(Node leftChild, Node rightChild)
{
    Node parentNode;
    parentNode.maxPrefixSum = max(leftChild.maxPrefixSum,
                                  leftChild.totalSum +
                                  rightChild.maxPrefixSum);

    parentNode.maxSuffixSum = max(rightChild.maxSuffixSum,
                                  rightChild.totalSum +
                                  leftChild.maxSuffixSum);

    parentNode.totalSum = leftChild.totalSum +
                          rightChild.totalSum;

    parentNode.maxSubarraySum = max({leftChild.maxSubarraySum,
                                     rightChild.maxSubarraySum,
                                     leftChild.maxSuffixSum +
                                     rightChild.maxPrefixSum});

    return parentNode;
}
void constructTreeUtil(Node* tree, int arr[], int start,
                                    int end, int index)
{

    if (start == end) {

        tree[index].totalSum = arr[start];
        tree[index].maxSuffixSum = arr[start];
        tree[index].maxPrefixSum = arr[start];
        tree[index].maxSubarraySum = arr[start];
        return;
    }

    int mid = (start + end) / 2;
    constructTreeUtil(tree, arr, start, mid, 2 * index);
    constructTreeUtil(tree, arr, mid + 1, end, 2 * index + 1);

    tree[index] = merge(tree[2 * index], tree[2 * index + 1]);
}


Node* constructTree(int arr[], int n)
{

    int x = (int)(ceil(log2(n)));

    int max_size = 2 * (int)pow(2, x) - 1;
    Node* tree = new Node[max_size];


    constructTreeUtil(tree, arr, 0, n - 1, 1);


    return tree;
}


Node queryUtil(Node* tree, int ss, int se, int qs,int qe, int index)
{

    if (ss > qe || se < qs) {
        Node nullNode;
        return nullNode;
    }


    if (ss >= qs && se <= qe) {
        return tree[index];
    }

    int mid = (ss + se) / 2;
    Node left = queryUtil(tree, ss, mid, qs, qe,
                                     2 * index);
    Node right = queryUtil(tree, mid + 1, se, qs,
                              qe, 2 * index + 1);


    Node res = merge(left, right);
    return res;
}


int query(Node* tree, int start, int end, int n)
{
    Node res = queryUtil(tree, 0, n - 1, start, end, 1);
    return res.maxSubarraySum;
}


Node* add(Node* tree,int k, int x,int n) {
k += n;
tree[k].totalSum = x;
tree[k].maxSuffixSum = x;
tree[k].maxPrefixSum = x;
tree[k].maxSubarraySum = x;
for (k /= 2; k >= 1; k /= 2) {
tree[k] = merge(tree[2*k],tree[2*k+1]);
}

return tree;
}


int main()
{
    int n;
    cin>>n;
    int arr[n];
    for(int i=0;i<n;i++){
        int y;
        cin>>y;
        arr[i]=y;
    }


    Node* Tree = constructTree(arr, n);
    int start, end, maxSubarraySum;



    int m;
    cin>>m;

    for(int i=0;i<m;i++){
        int c,a,b;
        cin>>c>>a>>b;
        if(c==1){
            start=a;
            end=b;
            cout<<query(Tree,start-1,end-1,n)<<endl;
        }else{
           Tree=add(Tree,a-1,b,n);
        }
    }







    return 0;
}