#include <iostream>
#include <vector>

std::vector<int> suma_na_przedziale;
std::vector<int> nie_zaktualizowane_wartosci_synow;
 
int ZnajdzNajblizszaWiekszaPotegeDwojki (int liczba) {
 int najblizsza_potega_dwojki;

 najblizsza_potega_dwojki = 1;
 while (najblizsza_potega_dwojki < liczba)
    najblizsza_potega_dwojki <<= 1;

 return najblizsza_potega_dwojki;
}

void PrzekazNiezaktualizowaneWartosciSynom (int wierzcholek) {
 int syn_lewy, syn_prawy;

 syn_lewy  = 2*wierzcholek;
 syn_prawy = 2*wierzcholek + 1;

 suma_na_przedziale[syn_lewy]  += nie_zaktualizowane_wartosci_synow[wierzcholek];
 suma_na_przedziale[syn_prawy] += nie_zaktualizowane_wartosci_synow[wierzcholek];

 nie_zaktualizowane_wartosci_synow[syn_lewy]  += nie_zaktualizowane_wartosci_synow[wierzcholek]/2;
 nie_zaktualizowane_wartosci_synow[syn_prawy] += nie_zaktualizowane_wartosci_synow[wierzcholek]/2;

 nie_zaktualizowane_wartosci_synow[wierzcholek]  = 0;
}
 
void DodajWartoscNaPrzedzialeWDrzewie (int wartosc, int poczatek_podanego_przedzialu, int koniec_podanego_przedzialu,
                                       int wierzcholek, int poczatek_zakresu_wierzcholka, int koniec_zakresu_wierzcholka) {
 int srodek, suma;

//jesli mamy dodać cos na przedziale za który nasz wierzchołek NIE odpowiada - chocćby częściowo - wychodzimy
 if ( koniec_podanego_przedzialu < poczatek_zakresu_wierzcholka)
    return;
 if ( poczatek_podanego_przedzialu > koniec_zakresu_wierzcholka)
    return;

//jesli mamy dodać cos na takim przedziale, w którym zakres naszego wierzchołka mieści się w całości
//to aktulizujemy sumę za która odpowiada nasz wierzchołek
//nie aktulizujemy naszych dzieci - zrobimy to w przyzłości gdy będzie trzeba na podstawie
//tablicy nie_zaktualizowane_wartosci_synow
 if ( (poczatek_zakresu_wierzcholka >= poczatek_podanego_przedzialu) && 
      (koniec_zakresu_wierzcholka <= koniec_podanego_przedzialu) ) {
    suma = wartosc * (koniec_zakresu_wierzcholka - poczatek_zakresu_wierzcholka + 1);
    suma_na_przedziale[wierzcholek] += suma;
    nie_zaktualizowane_wartosci_synow[wierzcholek] += suma/2;
    return;
 }

//jesli nasz przedział zawiera fagment częsciowo zakres na którym dodajemy
//ale też przedział spoza aktulizowanego zakresu 
//to aktualizujemy synów z wcześniejszych pytan (nie_zaktualizowane_wartosci_synow)
//oraz przekazujemy im aktualny rozkaz
//nastepnie aktulizujemy naszą sumę
 PrzekazNiezaktualizowaneWartosciSynom (wierzcholek);
 srodek = (poczatek_zakresu_wierzcholka + koniec_zakresu_wierzcholka) / 2;
 DodajWartoscNaPrzedzialeWDrzewie (wartosc, poczatek_podanego_przedzialu, koniec_podanego_przedzialu,
                                   2*wierzcholek, poczatek_zakresu_wierzcholka, srodek);
 DodajWartoscNaPrzedzialeWDrzewie (wartosc, poczatek_podanego_przedzialu, koniec_podanego_przedzialu,
                                   2*wierzcholek+1, srodek+1, koniec_zakresu_wierzcholka);
                           
 suma_na_przedziale[wierzcholek] = suma_na_przedziale[2*wierzcholek] + suma_na_przedziale[2*wierzcholek+1]; 
}

int ObliczSumePrzedzialuWDrzewie (int poczatek_podanego_przedzialu, int koniec_podanego_przedzialu,
                                  int wierzcholek, int poczatek_zakresu_wierzcholka, int koniec_zakresu_wierzcholka) {
 int suma_przedzialu_syna_lewego, suma_przedzialu_syna_prawego;
 int srodek;

//jeśli pytanie spoza zakresu wierzchołka to zwracamy 0 - suma którą dokłada ten wierzchołek do wyniku jest 0
 if ( koniec_podanego_przedzialu < poczatek_zakresu_wierzcholka )
    return 0;
 if ( poczatek_podanego_przedzialu > koniec_zakresu_wierzcholka )
    return 0;

//jeśli nasz wierzchołek w całości zawiera się w pytanym zakresie to nasz wierzchołek dokłada się do sumy w całości
//zwracamy sumę którą przechowuje nasz wierzchołek
 if ( (poczatek_zakresu_wierzcholka >= poczatek_podanego_przedzialu) && 
      (koniec_zakresu_wierzcholka <= koniec_podanego_przedzialu) ) {
    return suma_na_przedziale[wierzcholek];
 }

//jeśli nasz wierzchołek zawiera coś z pytanego zakresu ale też coś spoza pytanego zakresu to nie możemy od razu odpowiedzieć
//pytamy synów i zwracamy sumę ich odpowiedzi
//ale najpierw aktualizujemy ich wartości wcześniejszymi zapytaniami na które nie musieli odpowiadać
 PrzekazNiezaktualizowaneWartosciSynom (wierzcholek);

 srodek = (poczatek_zakresu_wierzcholka + koniec_zakresu_wierzcholka) / 2;
 suma_przedzialu_syna_lewego = ObliczSumePrzedzialuWDrzewie (poczatek_podanego_przedzialu, koniec_podanego_przedzialu,
                                                             2*wierzcholek, poczatek_zakresu_wierzcholka, srodek);
 suma_przedzialu_syna_prawego = ObliczSumePrzedzialuWDrzewie (poczatek_podanego_przedzialu, koniec_podanego_przedzialu,
                                                              2*wierzcholek+1, srodek+1, koniec_zakresu_wierzcholka);

 return suma_przedzialu_syna_lewego + suma_przedzialu_syna_prawego;
}  

int main (){
 std::ios_base::sync_with_stdio(0);
 std::cin.tie(0);
 std::cout.tie(0);

 int ile_pracownikow, ile_operacji;
 char operacja;
 int liczba_przechowywanych_elementow, rozmiar_drzewa;
 int poczatek, koniec, wartosc;
 int i;
  
 std::cin >> ile_pracownikow >> ile_operacji;

//drzewo musi przechowywać elementy będące potęgą dwójki
//rozmiar drzewa jest dwa razy większy od ilości przechowywanych elementów    
 liczba_przechowywanych_elementow = ZnajdzNajblizszaWiekszaPotegeDwojki (ile_pracownikow);
 rozmiar_drzewa = 2 * liczba_przechowywanych_elementow;
 suma_na_przedziale.resize(rozmiar_drzewa, 0);
 nie_zaktualizowane_wartosci_synow.resize(rozmiar_drzewa, 0);

 for (i=1; i<=ile_operacji; ++i) {
 	std::cin >> operacja >> poczatek >> koniec;
 	if ( operacja == 'P') {
 	   std::cout << ObliczSumePrzedzialuWDrzewie (poczatek-1, koniec-1, 1, 0, liczba_przechowywanych_elementow-1) << "\n";
 	   continue;
    }
 	std::cin >> wartosc;
    DodajWartoscNaPrzedzialeWDrzewie (wartosc, poczatek-1, koniec-1, 1, 0, liczba_przechowywanych_elementow-1);
 }

 return 0;
}