#include <algorithm>
#include <array>
// #include <bitset>
#include <cassert>
// #include <cctype>
// #include <climits>
// #include <cmath>
// #include <cstdarg>
#include <cstdint>
// #include <cstdio>
// #include <cstdlib>
// #include <cstring>
// #include <ctime>
// #include <deque>
#include <fstream>
// #include <functional>
// #include <iomanip>
#include <iostream>
// #include <list>
// #include <map>
#include <memory>
// #include <numeric>
// #include <queue>
// #include <random>
// #include <ranges>
// #include <set>
// #include <sstream>
// #include <stack>
// #include <string>
// #include <tuple>
// #include <unordered_map>
// #include <unordered_set>
// #include <utility>
#include <vector>
using std::cin;using std::cout;using std::cerr;
using std::ifstream;using std::ofstream;
// #define ONLINE_JUDGE
// #define ___file_name ""
typedef int8_t i8;typedef uint8_t u8;
typedef int16_t i16;typedef uint16_t u16;
typedef int32_t i32;typedef uint32_t u32;
typedef int64_t i64;typedef uint64_t u64;
typedef float f32;typedef double f64;
#if(defined(_GLIBCXX_QUEUE))
template<typename T>class min_heap:public std::priority_queue<T,std::vector<T>,std::less<T>>{};
template<typename T>class max_heap:public std::priority_queue<T,std::vector<T>,std::greater<T>>{};
#endif
#define for_it(i,a) for(decltype(a.begin()) i((a).begin());i!=(a).end();++i)
#define for_it_it(i,a) for(decltype((a)->begin()) i((a)->begin());i!=(a)->end();++i)
#define rfor_it(i,a) for(decltype(a.rbegin()) i((a).rbegin());i!=(a).rend();++i)
#define rfor_it_it(i,a) for(decltype((a)->rbegin()) i((a)->rbegin());i!=(a)->rend();++i)
#define rgof(a) a.begin(),a.end()
#if(!defined(ONLINE_JUDGE))
ofstream out_log;
#endif
template<typename T>void resize(T& a,size_t size)
{a.resize(size);}
template<typename T,typename... T1>void resize(T& a,size_t now_size,T1 ...size)
{a.resize(now_size);for(auto& i:a){resize(i,size...);}}
namespace ___funcs{
	template<typename T>T& max(T& a,T& b){return a>b?a:b;}
	template<typename T,typename... A>T& max(T& a,T& b,A& ...c){return max(a=max(a,b),c...);}
	template<typename T>T& min(T& a,T& b){return a<b?a:b;}
	template<typename T,typename... A>T& min(T& a,T& b,A& ...c){return min(a=min(a,b),c...);}
}
template<typename T,typename... A>T max(T a,A ...b){return ___funcs::max(a,b...);}
template<typename T,typename... A>T min(T a,A ...b){return ___funcs::min(a,b...);}

int n,m;
std::vector<int> a;
/*
max:a.at(0).at(0)
h_max:a.at(0).at(1)
a:[max,h_max,0]
add:[
	[k,-inf,-inf],
	[k,0,-inf],
	[-inf,-inf,0]
]
cover:[
	[-inf,-inf,-inf],
	[-inf,0,-inf],
	[k,k,0]
]
*/

template<typename value_type,size_t n,size_t m>
class matrix{
	public:
	std::array<std::array<value_type,m>,n> a;
	matrix(){
		for_it(i,a){
			std::fill(i->begin(),i->end(),INT_MIN);
		}
	}
	std::array<value_type,m>& at(size_t k){
		return a.at(k);
	}
	template<size_t p>
	matrix<value_type,n,p> operator*(matrix<value_type,m,p>& b){
		matrix<value_type,n,p> c;
		for(size_t k(0),i,j;k<m;++k){
			for(i=0;i<n;++i){
				for(j=0;j<p;++j){
					c.at(i).at(j)=max(c.at(i).at(j),(this->at(i)).at(k)+b.at(k).at(j));
				}
			}
		}
		return c;
	}
};
class node{
	public:
	matrix<i64,1,3> a;
	matrix<i64,3,3> lz;
	std::unique_ptr<node> ls,rs;
};
typedef std::unique_ptr<node> upn;
upn root;

void _build(upn& u,int l,int r){
	u=std::make_unique<node>();
	for_it(i,u->a.a){
		std::fill(i->begin(),i->end(),0);
	}
	for(u32 i(0),j;i<3;++i){
		for(j=0;j<3;++j){
			u->lz.a.at(i).at(j)=(i==j?0:INT_MIN);
		}
	}
	if(l==r){
		u->a.a=std::array<std::array<i64,3>,1>({std::array<i64,3>{a.at(l),a.at(l),0}});
		return;
	}
	int mid((l+r)>>1);
	_build(u->ls,l,mid);
	_build(u->rs,mid+1,r);
	u->a.at(0).at(0)=max(u->ls->a.at(0).at(0),u->rs->a.at(0).at(0));
	u->a.at(0).at(1)=max(u->ls->a.at(0).at(1),u->rs->a.at(0).at(1));
	u->a.at(0).at(2)=0;
}
void build(){
	_build(root,0,n-1);
}
void tag(char o,int k,upn& u){
	matrix<i64,3,3> a;
	if(o=='P'){
		a.a=std::array<std::array<i64,3>,3>({
			std::array<i64,3>({k,INT_MIN,INT_MIN}),
			std::array<i64,3>({k,0,INT_MIN}),
			std::array<i64,3>({INT_MIN,INT_MIN,0})
		});
	}else{
		a.a=std::array<std::array<i64,3>,3>({
			std::array<i64,3>({INT_MIN,INT_MIN,INT_MIN}),
			std::array<i64,3>({INT_MIN,0,INT_MIN}),
			std::array<i64,3>({k,k,0})
		});
	}
	u->a=u->a*a;
	u->lz=u->lz*a;
}
void push_down(upn& u){
	u->ls->a=u->ls->a*u->lz;
	u->ls->lz=u->ls->lz*u->lz;
	u->rs->a=u->rs->a*u->lz;
	u->rs->lz=u->rs->lz*u->lz;
	for(u32 i(0),j;i<3;++i){
		for(j=0;j<3;++j){
			u->lz.a.at(i).at(j)=(i==j?0:INT_MIN);
		}
	}
}
void _update(char o,int x,int y,int k,upn& u,int l,int r){
	if(r<x||y<l){
		return;
	}
	if(x<=l&&r<=y){
		tag(o,k,u);
		return;
	}
	push_down(u);
	int mid((l+r)>>1);
	_update(o,x,y,k,u->ls,l,mid);
	_update(o,x,y,k,u->rs,mid+1,r);
}
void update(char o,int x,int y,int k){
	_update(o,x,y,k,root,0,n-1);
}
int _query(char o,int x,int y,upn& u,int l,int r){
	if(r<x||y<l){
		return INT_MIN;
	}
	if(x<=l&&r<=y){
		return o=='Q'?u->a.at(0).at(0):u->a.at(0).at(1);
	}
	push_down(u);
	int mid((l+r)>>1);
	return max(_query(o,x,y,u->ls,l,mid),_query(o,x,y,u->rs,mid+1,r));
}
int query(char o,int x,int y){
	return _query(o,x,y,root,0,n-1);
}
void ___main(){
	char o;
	cin>>n;
	resize(a,n);
	for_it(i,a){
		cin>>(*i);
	}
	cin>>m;
	build();
	for(int i(0),x,y,z;i<m;++i){
		cin>>o>>x>>y;
		--x;--y;
		if(o=='Q'||o=='A'){
			cout<<query(o,x,y)<<'\n';
		}else{
			cin>>z;
			update(o,x,y,z);
		}
	}
}
int main(){
	std::cin.tie(nullptr)->sync_with_stdio(false);
#if(!defined(ONLINE_JUDGE))
	ifstream input_file("1.in");ofstream output_file("1.out"),debug_file("1.debug");out_log.open("1.log");
	std::streambuf *cinbuf(cin.rdbuf(input_file.rdbuf())),*coutbuf(cout.rdbuf(output_file.rdbuf())),*cerrbuf(cerr.rdbuf(debug_file.rdbuf()));
#endif
	___main();
#if(!defined(ONLINE_JUDGE))
	cin.rdbuf(cinbuf);cout.rdbuf(coutbuf);cerr.rdbuf(cerrbuf);
#endif
	return 0;
}