#define _CRT_SECURE_NO_WARNINGS

#include<iostream>

#include<stdio.h>

using namespace std;

#define MAX_COUNT 100005

#define MAX(a, b) a>b? a:b

#define MIN(a, b) a<b? a:b

//查找两个相交的区间的并长度（即两个区间覆盖的总长度）

int Interval(int beg1, int end1, int beg2, int end2){

    int tmp = MAX(end1, end2);

    //注意不要  MAX(end1, end2) -MIN(beg1, beg2), 因为这样做在编译的时候宏定义展开，

    //和三目运算符一块，优先级导致结果出错！！！！

    tmp -= MIN(beg1, beg2);

    return (end1 - beg1 + end2 - beg2) - tmp + ;

}

int gNumCount, gQueryCount; //总的数字的数目，总的查询次数

int gNumber[MAX_COUNT]; //线段树节点的数组

//线段树节点的定义

struct TreeNode{

    int begin;    //该节点覆盖区间的左边界

    int end;    //该节点覆盖区间的右边界

    long long sum;    //该节点覆盖区间的当前sum值，不包括 inc 可能增加的那些值（即实际的和应该为 sum + inc *(end - begin+1)

    long long inc;    //该节点覆盖区间中的那些点 应该被增加的值（注意是该区间的所有点）

};

struct TreeNode gTreeNodes[MAX_COUNT*];

//自底向上的更新，将左右子的 sum 值相加得到 该节点的sum值

void PushUp(int node_index){

    int left_child =  * node_index + ;

    int right_child =  * node_index + ;

    gTreeNodes[node_index].sum = gTreeNodes[left_child].sum + gTreeNodes[right_child].sum;

}

//自顶向下的更新操作，当该节点不能被查询区间全部覆盖，则需要向下走，去其子节点位置进行查询

//在查询之前，需要将 inc 值传递到子节点，同时该节点的sum值更新，inc值清零

void PushDown(int node_index){

    TreeNode* node = gTreeNodes + node_index;

    int left_child =  * node_index + ;

    int right_child =  * node_index + ;

    node->sum += node->inc*(node->end - node->begin + );

    gTreeNodes[left_child].inc += node->inc;

    gTreeNodes[right_child].inc += node->inc;

    node->inc = ;

}

void BuildTree(int node_index, int beg, int end){

    TreeNode* node = gTreeNodes + node_index;

    node->inc = node->sum = ;

    node->begin = beg;

    node->end = end;

    if (beg ==  end){

        node->sum = gNumber[beg];

        return;

    }

    int mid = (beg + end) / , left_child =  * node_index + , right_child =  * node_index + ;

    BuildTree(left_child, beg, mid);

    BuildTree(right_child, mid + , end);

    //自底向上更新

    PushUp(node_index);

}

void Add(int node_index, int beg, int end, long long c){

    TreeNode* node = gTreeNodes + node_index;

    int left_child =  * node_index + , right_child =  * node_index + , mid = (node->begin + node->end) / ;

    if (node->begin > end || node->end < beg){

        return;

    }

    //如果当前结点被查询区间全部覆盖，则不向下传递，直接将inc值增加

    if (node->begin >= beg && node->end <= end){

        node->inc += c;

        return;

    }

    //如果节点不能被查询区间全部覆盖，则需要分裂节点向下传递，此时的sum值需要增加（inc * 两区间重合的长度）

    //而同时 inc 值保持不变

    node->sum += (Interval(node->begin, node->end, beg, end) * c);

    int end1 = MIN(end, mid);

    int beg1 = MAX(beg, mid + );

    Add(left_child, beg, end1, c);

    Add(right_child, beg1, end, c);

}

long long QuerySum(int node_index, int beg, int end){

    TreeNode* node = gTreeNodes + node_index;

//    printf("node %d's sum = %d\n", node_index, gTreeNodes[node_index].sum);

//    printf("node->beg = %d, node->end = %d, beg = %d, end = %d\n", node->begin, node->end, beg, end);

    int left_child =  * node_index + , right_child =  * node_index + , mid = (node->begin + node->end) / ;

    long long sum = ;

    if (node->begin > end || node->end < beg){

        return sum;

    }

    if (node->begin >= beg && node->end <= end){

        sum  += (node->sum + node->inc*(node->end - node->begin + ));

    }

    else{

        //向下分裂的更新操作

        PushDown(node_index);

        int end1 = MIN(end, mid);

        int beg1 = MAX(beg, mid + );

        long long sum_left = QuerySum(left_child, beg, end1);

        long long sum_right = QuerySum(right_child, beg1, end);

        sum += (sum_left + sum_right);

    }

    return sum;

}

int main(){

    scanf("%d %d", &gNumCount, &gQueryCount);

    for (int i = ; i < gNumCount; i++){

        scanf("%d", gNumber + i);

    }

    BuildTree(, , gNumCount - );

    char op;

    int a, b;

    long long c;

    long long result;

    for (int i = ; i < gQueryCount; i++){

        getchar();

        scanf("%c", &op);

        if (op == 'C'){

            scanf("%d %d %lld", &a, &b, &c);

            Add(, a- , b-, c);

            /*

            for (int k = 0; k < 27; k++){

                printf("node[%d]'s sum = %lld, inc = %lld\n", k, gTreeNodes[k].sum, gTreeNodes[k].inc);

            }

            */

        }

        else if (op == 'Q'){

            scanf("%d %d", &a, &b);

            result = QuerySum(, a-, b-);

            printf("%lld\n", result);

        }

    }

    return ;

}