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

inline int read()
{
	register int x = 0, f = 1;
	register char c = getchar();
	while(c < '0' || c > '9')
	{
		if(c == '-')f = -1;
		c = getchar();
	}
	while(c <= '9' && c >= '0')
	{
		x = x * 10 + c - '0';
		c = getchar();
	}
	return x * f;
}

inline void write(int x)
{
	if(!x)return;
	write(x / 10);
	putchar(x % 10 + '0');
	return; 
}

struct node
{
	int val, ch[2], rnd, size, lsum, rsum, sum, num, lazy, set;
}t[500010];

struct pr
{
	int start, len;
};

bool deleted[500010];

queue <pr> qu;

int newnode(int val)
{
	pr a = qu.front();
	qu.pop();
	int cnt = a.start;
	deleted[cnt] = 0;
	t[cnt].ch[0] = t[cnt].ch[1] = 0;
	t[cnt].lsum = t[cnt].rsum = t[cnt].sum = t[cnt].num = val;
	t[cnt].rnd = rand();
	t[cnt].size = 1;
	t[cnt].val = val;
	t[cnt].lazy = t[cnt].set = 0;
	if(a.len > 1)a.len--, a.start++, qu.push(a);
	return cnt;
}

void pushdown(int q)
{
	if(t[q].set)
	{
		t[t[q].ch[0]].set = t[t[q].ch[1]].set = t[q].set;
		t[q].lsum = t[q].rsum = t[q].sum = t[q].num = (t[q].set * t[q].size);
		t[q].val = t[q].set;
		t[q].set = 0;
	}
	if(t[q].lazy)
	{
		t[t[q].ch[0]].lazy ^= 1;
		t[t[q].ch[1]].lazy ^= 1;
		swap(t[q].ch[0], t[q].ch[1]);
		swap(t[q].lsum, t[q].rsum);
		t[q].lazy = 0;
	}
	return;
}

void update(int q)
{
	pushdown(q);
	pushdown(t[q].ch[0]);
	pushdown(t[q].ch[1]);
	t[q].size = t[t[q].ch[0]].size + t[t[q].ch[1]].size + 1;
	t[q].lsum = max(t[t[q].ch[0]].sum + t[q].val + t[t[q].ch[1]].lsum, t[t[q].ch[0]].lsum);
	t[q].rsum = max(t[t[q].ch[1]].sum + t[q].val + t[t[q].ch[0]].rsum, t[t[q].ch[1]].rsum);
	t[q].sum = max(t[t[q].ch[1]].sum, t[t[q].ch[0]].rsum + t[q].val + t[t[q].ch[1]].lsum);
	t[q].sum = max(t[q].sum, t[t[q].ch[0]].sum);
	t[q].num = t[t[q].ch[0]].num + t[t[q].ch[1]].num + t[q].val;
	return;
}

void split(int id, int k, int &x, int &y)
{
	if(!id)
	{
		x = y = 0;
		return;
	}
	pushdown(id);
	int lsize = t[t[id].ch[0]].size;
	if(lsize < k)
	{
		x = id;
		split(t[x].ch[1], k - lsize - 1, t[x].ch[1], y);
	}
	else
	{
		y = id;
		split(t[y].ch[0], k, x, t[y].ch[0]);
	}
	update(id);
	return;
}

int merge(int x, int y)
{
	if(!x || !y)
	{
		return x + y;
	}
	pushdown(x);
	pushdown(y);
	if(t[x].rnd < t[y].rnd)
	{
		t[x].ch[1] = merge(t[x].ch[1], y);
		update(x);
		return x;
	}
	else
	{
		t[y].ch[0] = merge(x, t[y].ch[0]);
		update(y);
		return y;
	}
}

int n, m, rt;

void dlt(int q)
{
	if(q == 0)return;
	dlt(t[q].ch[0]);
	dlt(t[q].ch[1]);
	pr a;
	deleted[q] = 1;
	a.start = q, a.len = 1;
	qu.push(a);
	return;
}

void query(int x)
{
	if(!x)return;
//	pushdown(x);
	if(!deleted[t[x].ch[0]])query(t[x].ch[0]);
	cout << x << " " << t[x].val << " " << t[x].lsum << " " << t[x].rsum << " " << t[x].sum << " " << t[x].size << " " << t[x].lazy << " " << t[x].set << " " << t[x].num << " " << t[x].ch[0] << " " << t[x].ch[1] << "\n";
	if(!deleted[t[x].ch[1]])query(t[x].ch[1]);
//	update(x);
	return;
}

signed main()
{
	memset(deleted, 1, sizeof(deleted)); 
	cin >> n >> m;
	pr a;
	a.start = 1, a.len = 500000;
	qu.push(a);
	for(int i = 1;i <= n;i++)
	{
		int val;
		val = read();
		rt = merge(rt, newnode(val));
	}
	string s;
	while(m--)
	{
		cin >> s;
		if(s == "GET-SUM")
		{
			int pos, len;
			pos = read(), len = read();
			int x, y, z;
			split(rt, pos - 1, x, y);
			split(y, len, y, z);
			if(y)
			{
				cout << t[y].num << "\n";
			}
//			query(y);
			rt = merge(x, merge(y, z));
		}
		if(s == "INSERT")
		{
			int pos, tot, x, y;
			pos = read(), tot = read();
			split(rt, pos, x, y);
			for(int i = 1;i <= tot;i++)
			{
				int val = read();
				x = merge(x, newnode(val));
			}
			rt = merge(x, y);
		}
		if(s == "DELETE")
		{
			int pos, len;
			pos=  read(), len = read();
			int x, y, z;
			split(rt, pos - 1, x, y);
			split(y, len, y, z);
			dlt(y);
			rt = merge(x, z);
		}
		if(s == "MAKE-SAME")
		{
			int pos, len, x, y, st, z;
			pos = read(), len = read(), st = read();
			split(rt, pos - 1, x, y);
			split(y, len, y, z);
			if(y)
			{
				t[y].set = st;
				t[y].val = st;
			}
			rt = merge(x, merge(y, z));
		}
		if(s == "REVERSE")
		{
			int pos, len, x, y, z;
			pos = read(), len = read();
			split(rt, pos - 1, x, y);
			split(y, len, y, z);
			if(y)
			{
				t[y].lazy ^= 1;
			}
			rt = merge(x, merge(y, z));
		}
		if(s == "MAX-SUM")
		{
//			query(rt);
			update(rt);
			cout << t[rt].sum << "\n";
		}
//		query(rt);
	}
	return 0;
}