/*/ Author: kal013 /*/

// #pragma GCC optimize ("O3")

#include "bits/stdc++.h"
#include "ext/pb_ds/assoc_container.hpp"
#include "ext/pb_ds/tree_policy.hpp"
using namespace std;
using namespace __gnu_pbds;

template<class T>
using ordered_set = tree<T, null_type,less<T>,
rb_tree_tag,tree_order_statistics_node_update> ;

template<class key, class value, class cmp = std::less<key>>

using ordered_map = tree<key, value, cmp, rb_tree_tag,
tree_order_statistics_node_update>;
// find_by_order(k) returns iterator to kth element starting from 0;
// order_of_key(k) returns count of elements strictly smaller than k;

struct custom_hash { // Credits: https://codeforces.com/blog/entry/62393

static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}

size_t operator()(uint64_t x) const {

static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};

template<class T> ostream& operator<<(ostream &os, vector<T> V) {

os << "[ ";
for(auto v : V) os << v << " ";
return os << "]";
}
template<class T> ostream& operator<<(ostream &os, set<T> S){
os << "{ ";
for(auto s:S) os<<s<<" ";
return os<<"}";
}
template<class T> ostream& operator<<(ostream &os, unordered_set<T> S){
os << "{ ";
for(auto s:S) os<<s<<" ";
return os<<"}";
}
template<class T> ostream& operator<<(ostream &os, ordered_set<T> S){
os << "{ ";
for(auto s:S) os<<s<<" ";
return os<<"}";
}
template<class L, class R> ostream& operator<<(ostream &os, pair<L,R> P) {
return os << "(" << P.first << "," << P.second << ")";
}
template<class L, class R> ostream& operator<<(ostream &os, map<L,R> M) {
os << "{ ";
 for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
return os<<"}";
}
template<class L, class R> ostream& operator<<(ostream &os, unordered_map<L,R> M) {
os << "{ ";
for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
return os<<"}";
}
template<class L, class R, class chash = std::hash<R> > ostream& operator<<(ostream
&os, gp_hash_table<L,R,chash> M) {
os << "{ ";
for(auto m:M) os<<"("<<m.first<<":"<<m.second<<") ";
return os<<"}";
}

#define TRACE
#ifdef TRACE
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char* name, Arg1&& arg1){
cerr << name << " : " << arg1 << endl;
}
template <typename Arg1, typename... Args>
void __f(const char* names, Arg1&& arg1, Args&&... args){
const char* comma = strchr(names + 1, ',');
cerr.write(names, comma - names) << " : " << arg1<<" | ";
__f(comma+1, args...);
}
#else
#define trace(...) 1
#endif

mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());

inline int64_t random_long(long long l,long long r){

uniform_int_distribution<int64_t> generator(l,r);
return generator(rng);
}
inline int64_t random_long(){
uniform_int_distribution<int64_t> generator(LLONG_MIN,LLONG_MAX);
return generator(rng);
}

/*/---------------------------Defines----------------------/*/
#define int long long

typedef vector<int> vi;

typedef pair<int,int> pii;

#define ll long long

#define F first
#define S second
#define pb push_back
#define endl "\n"
#define all(v) (v).begin(),(v).end()
/*/-----------------------Modular Arithmetic---------------/*/

const int mod=1e9+7;

inline int add(int x,int y){
x+=y;
if (x>=mod) return x-mod;
return x;
}
inline int sub(int x,int y){
x-=y;
if (x<0) return x+mod;
return x;
}
inline int mul(int x,int y){
return (x*1ll*y)%mod;
}
inline int power(int x,int y){
int ans=1;
while(y){
if (y&1) ans=mul(ans,x);
x=mul(x,x);
y>>=1;
}
return ans;
}
inline int inv(int x){
return power(x,mod-2);
}

/*/-----------------------------Code begins----------------------------------/*/

const int N = 2e5 + 100;

int bit1[N], bit2[N];

int M;
void init(){
for(int i=1;i<=M;++i) {bit1[i]=0;bit2[i]=0;}
}

void upd_1(int x,int y){

while(x<=M){
bit1[x] += y;
x += (x&(-x));
}
}

int query_1(int x){

int ans = 0;
while(x>0){
ans += bit1[x];
x -= (x&(-x));
}
return ans;
}

void upd_2(int x,int y){

while(x<=M){
bit2[x] += y;
x += (x&(-x));
}
}
int query_2(int x){
int ans = 0;
while(x>0){
ans += bit2[x];
x -= (x&(-x));
}
return ans;
}

int q_1(int l,int r){

if (l>r) return 0;
return query_1(r)-query_1(l-1);
}

int q_2(int l,int r){

if(l>r) return 0;
return query_2(r) - query_2(l-1);
}

int ans_query(int l,int r){

assert(l>=1 && l<=r);
int v1 = q_1(l,r), v2 = q_2(l,r);
v1 -= (l-1)*v2;
if (l&1){
return -v1;
}
else return v1;
}

int A[N];
void solve(){
int n,q;
cin>>n>>q;
M = n;
init();
int mul = 1;
for(int i=1;i<=n;++i){
cin>>A[i];
mul *= -1;
upd_1(i,mul*i*A[i]);
upd_2(i,mul*A[i]);
}

int ans = 0;
for(int i=0;i<q;++i){
int l,r;
char x;
cin>>x>>l>>r;
if (x == 'Q'){
// trace(l,r,M);
ans += ans_query(l,r);
}
else{
int mul = (l&1)?-1:1;
int dif = r - A[l];
upd_1(l,mul*l*dif);
upd_2(l,mul*dif);
 A[l] = r;
}
}
cout<<ans<<endl;
}
signed main(){
// Use "set_name".max_load_factor(0.25);"set_name".reserve(512); with unordered
set
// Or use gp_hash_table<X,null_type>
ios_base::sync_with_stdio(false);cin.tie(NULL);cout.tie(NULL);
cout<<fixed<<setprecision(25);
int t;
cin>>t;
for(int i=1;i<=t;++i){
cout<<"Case #"<<i<<": ";
solve();
}
}