#include<bits/stdc++.h>
#include<iostream>

#define MAX  9223372036854775807;
#define MIN -9223372036854775807;


using namespace std;
typedef long long int lli;
lli A[100010][2];

lli maxtree1[800080];
lli mintree1[800080];

lli maxtree2[800080];
lli mintree2[800080];

void maketree(int idx,int start,int end);
void update(int idx, int start, int end, int id, int x, int y);

lli query1(int idx,int start, int end, int b,int e);
lli query2(int idx,int start, int end, int b,int e);
lli query3(int idx,int start, int end, int b,int e);
lli query4(int idx,int start, int end, int b,int e);

int main()
{
        int n;
        cin >> n;
        for(int i=0;i<n;i++)
        {
                for(int j=0;j<2;j++)
                {
                        cin >> A[i][j];
                }
        }
        maketree(1,0,n-1);
        
        int q;
        cin >> q;
        while(q--)
        {
                char c;
                int x,y;
                cin >> c >> x >> y;
                if(c == 'Q')
                {
                        lli max1 = query1(1,0,n-1,x,y);
                        lli max2 = query2(1,0,n-1,x,y);
                        lli min1 = query3(1,0,n-1,x,y);
                        lli min2 = query4(1,0,n-1,x,y);
                        lli ans = max(max1 - min1, max2 - min2);
                        cout << ans << endl;
                }
                else
                {
                        int y1 ;
                        cin >> y1;
                        update(1,0,n-1,x,y,y1);
                }
        }
}

void update(int idx, int start, int end, int id, int x, int y)
{
        if(start == end && start == id)
        {
                A[start][0] = x;
                A[start][1] = y;
                maxtree1[idx] = A[start][0] - A[start][1];
                mintree1[idx] = A[start][0] - A[start][1];
                maxtree2[idx] = A[start][0] + A[start][1];
                mintree2[idx] = A[start][0] + A[start][1];
        }
        else if(id > end || id < start)
        {
                return ;
        }
        else
        {
                int mid = (start + end)/2;
                update(2*idx, start, mid,id,x,y);
                update(2*idx+1,mid+1,end,id,x,y);
                maxtree1[idx] = max(maxtree1[2*idx],maxtree1[2*idx+1]);
                mintree1[idx] = min(mintree1[2*idx],mintree1[2*idx+1]);
                maxtree2[idx] = max(maxtree2[2*idx],maxtree2[2*idx+1]);
                mintree2[idx] = min(mintree2[2*idx],mintree2[2*idx+1]);
        }
}

void maketree(int idx,int start,int end)
{
        if(start == end)
        {
                maxtree1[idx] = A[start][0] - A[start][1];
                mintree1[idx] = A[start][0] - A[start][1];
                maxtree2[idx] = A[start][0] + A[start][1];
                mintree2[idx] = A[start][0] + A[start][1];
        }
        else
        {
                int mid = (start + end)/2;
                maketree(2*idx,start,mid);
                maketree(2*idx+1,mid+1,end);
                maxtree1[idx] = max(maxtree1[2*idx],maxtree1[2*idx+1]);
                mintree1[idx] = min(mintree1[2*idx],mintree1[2*idx+1]);
                maxtree2[idx] = max(maxtree2[2*idx],maxtree2[2*idx+1]);
                mintree2[idx] = min(mintree2[2*idx],mintree2[2*idx+1]);
        }
}


lli query1(int idx,int start, int end, int b,int e)
{
        if(b > end || e < start)
        {
                return MIN;
        }
        else if(start >= b && end <= e)
        {
                return maxtree1[idx];
        }
        else
        {
                int mid = (start + end)/2;
                lli q1 = query1(2*idx,start,mid,b,e);
                lli q2 = query1(2*idx+1,mid+1,end,b,e);
                return max(q1,q2);
        }
}

lli query2(int idx,int start, int end, int b,int e)
{
        if(b > end || e < start)
        {
                return MIN;
        }
        else if(start >= b && end <= e)
        {
                return maxtree2[idx];
        }
        else
        {
                int mid = (start + end)/2;
                lli q1 = query2(2*idx,start,mid,b,e);
                lli q2 = query2(2*idx+1,mid+1,end,b,e);
                return max(q1,q2);
        }
}

lli query3(int idx,int start, int end, int b,int e)
{
        if(b > end || e < start)
        {
                return MAX;
        }
        else if(start >= b && end <= e)
        {
                return mintree1[idx];
        }
        else
        {
                int mid = (start + end)/2;
                lli q1 = query3(2*idx,start,mid,b,e);
                lli q2 = query3(2*idx+1,mid+1,end,b,e);
                return min(q1,q2);
        }
}

lli query4(int idx,int start, int end, int b,int e)
{
        if(b > end || e < start)
        {
                return MAX;
        }
        else if(start >= b && end <= e)
        {
                return mintree2[idx];
        }
        else
        {
                int mid = (start + end)/2;
                lli q1 = query4(2*idx,start,mid,b,e);
                lli q2 = query4(2*idx+1,mid+1,end,b,e);
                return min(q1,q2);
        }
}