hdu 3308

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <string>
#include <cstring>
#include <list>
#include <queue>
#include <stack>
#include <cmath>

using namespace std;

#define PF(x) (scanf("%d",&x))
#define PT(x,y) (scanf("%d%d",&x,&y))
#define PR(x) (printf("%d\n",x))
#define PRT(x,y)(printf("%d %d\n",x,y))
#define PB(x)(scanf("%I64d",&x))
#define PRB(x)(printf("%I64d\n",(x)))
#define For(i,n) for(int i=0;i<(n);i++)
#define CLR(ar) (memset(ar,0,sizeof(ar)))
#define CLR1(ar) (memset(ar,-1,sizeof(ar)))
#define PBE(x) (scanf("%I64d",&x)!=EOF)
#define Max(x,y) (x)>(y)?(x):(y)
#define Min(x,y) (x)>(y)?(y):(x)
#define L(x) (x<<1)
#define R(x) ((x<<1)|1)
#define Mid(x,y) ((x+y)>>1)

typedef __int64 LL;
#define N 100005
#define M 105
#define Mod 1000
#define Inf 0x7fffffff

struct tree
{
	int l,r;
	int var;
	int maxlen;
	int lmaxlen;
	int rmaxlen;
	int len()
	{
	   return  r-l+1;
	}
};

tree T[4*N];
int ar[N];
int n,m;

int maxx(int a,int b)
{
	return a>b?a:b;
}
int minx(int a,int b)
{
	return a>b?b:a;
}
void pushup(int node)
{
    if(T[node].l == T[node].r)
	{
		T[node].maxlen=1;
		T[node].lmaxlen=1;
		T[node].rmaxlen=1;
		return ;
	}
	else
	{
		int ll=T[L(node)].lmaxlen;
		int le = T[L(node)].len();
		if(ll==le && ar[T[R(node)].l]>ar[T[L(node)].r])
		{
			T[node].lmaxlen = ll + T[R(node)].lmaxlen;
		}
		else T[node].lmaxlen =ll;
		int lr=T[R(node)].rmaxlen;
		int re = T[R(node)].len();
		if(lr == re && ar[T[R(node)].l]>ar[T[L(node)].r])
		{
			T[node].rmaxlen = lr+T[L(node)].rmaxlen;
		}
		else T[node].rmaxlen = lr;

		int avar =-1;
		if(ar[T[R(node)].l]>ar[T[L(node)].r]) avar = T[L(node)].rmaxlen + T[R(node)].lmaxlen;
		avar = Max(avar,T[L(node)].lmaxlen);
		avar = Max(avar,T[L(node)].rmaxlen);
		avar = Max(avar,T[L(node)].maxlen);
		avar = Max(avar,T[R(node)].lmaxlen);
		avar = Max(avar,T[R(node)].rmaxlen);
		avar = Max(avar,T[R(node)].maxlen);
		T[node].maxlen = avar;
	}
}
void build(int l,int r,int k)
{
	T[k].l = l;
	T[k].r = r;
	T[k].var = 0;
	if(l == r)
	{
		T[k].var = ar[l];
		pushup(k);
		return ;
	}
	int mid = Mid(l,r);
	build(l,mid,L(k));
	build(mid+1,r,R(k));
	pushup(k);
}
void update(int pos,int k,int var)
{
	if(T[k].l == pos && T[k].r == pos)
	{
		T[k].var = var;
		ar[pos] = var;
		return ;
	}
	int mid = Mid(T[k].l,T[k].r);
	if(pos<=mid) update(pos,L(k),var);
	else update(pos,R(k),var);
	pushup(k);
}
int lens(int l,int r,int k)
{
	if(T[k].l ==l && T[k].r == r)
		return T[k].maxlen;

	int mid = Mid(T[k].l,T[k].r);
	if(r<=mid) return lens(l,r,L(k));
	if(l>mid) return lens(l,r,R(k));
	else
	{
		//int b,c;
		int ll = mid-l+1;
		int rl = r-mid;
		/*c = -1;
		if(ar[T[L(k)].r]<ar[T[R(k)].l])
		{
			int k = a>=ll?ll:a;
			int kk = b>=rl?rl:b;
			c = k+kk;
		}
		if(c>=ll+rl) return c;
		if(a>=ll) {a=ll;}
		else
		{
			a = Max(a,lens(l,mid,L(k)));
		}
		if(b>=rl){b = rl;}
		else 
		{
			b = Max(b,lens(mid+1,r,R(k)));
		}
		if(c>=r-l+1) c= r-l+1;
		a = Max(a,b);
		return Max(a,c);*/
		int a = maxx(lens(l,mid,L(k)),lens(mid+1,r,R(k)));
		if(ar[T[L(k)].r]<ar[T[R(k)].l])
			a = maxx(a,minx(T[L(k)].rmaxlen,ll)+minx(T[R(k)].lmaxlen,rl));
		return a;
	}
}
void init()
{
	int test;
	PF(test);
	while(test--)
	{
		PT(n,m);
		For(i,n) PF(ar[i+1]);
		build(1,n,1);

		For(i,m)
		{
			char s[10];
			scanf("%s",s);
			int x,y;
			PT(x,y);
			x++;

			if(s[0] == 'Q')
			{
				y++;
				PR(lens(x,y,1));
			}
			else
			{
				update(x,1,y);
			}
		}
	}
	return ;
}

int main()
{
	init();
	return 0;
}