import sys

from typing import List, Tuple


def int1(x: str, /): return int(x) - 1


def input(): return sys.stdin.readline().rstrip('\n')


def dbg(*args, **kwargs):
    print(*(repr(arg) for arg in args), *(f'{k}: {repr(v)}' for k, v in kwargs.items()), sep='; ', file=sys.stderr)


import abc, typing

T = typing.TypeVar('T')


class SegTree(typing.Generic[T], metaclass=abc.ABCMeta):

    @staticmethod
    @abc.abstractmethod
    def e() -> T:
        raise NotImplementedError

    @staticmethod
    @abc.abstractmethod
    def op(a: T, b: T) -> T:
        raise NotImplementedError

    def __len__(self):
        return self._n

    def __init__(self, param: typing.Union[int, typing.Iterable[T]]):
        if type(param) == int:
            self._n = param
        else:
            if type(param) != list:
                param = list(param)
            self._n = len(param)
        if self._n == 0:
            return
        self._lg = (self._n - 1).bit_length()
        self._arr = [self.e()] * (2 << self._lg)
        if type(param) != int:
            self._arr[1 << self._lg:(1 << self._lg) + self._n] = param
            for i in range((1 << self._lg) - 1, 0, -1):
                self._arr[i] = self.op(self._arr[i << 1], self._arr[(i << 1) | 1])

    def set(self, i: int, v: T):
        assert 0 <= i < self._n
        i += 1 << self._lg
        self._arr[i] = v
        for h in range(1, self._lg + 1):
            j = i >> h
            self._arr[j] = self.op(self._arr[j << 1], self._arr[(j << 1) | 1])

    def get(self, i: int):
        assert 0 <= i < self._n
        return self._arr[i + (1 << self._lg)]

    def prod(self, l: int, r: int):
        assert 0 <= l <= r <= self._n
        l, r = (1 << self._lg) + l, (1 << self._lg) + r
        sml = smr = self.e()
        while l < r:
            if l & 1:
                sml = self.op(sml, self._arr[l])
                l += 1
            if r & 1:
                r -= 1
                smr = self.op(smr, self._arr[r])
            l, r = l >> 1, r >> 1
        return self.op(sml, smr)


class SumSegTree(SegTree[int]):
    @staticmethod
    def e():
        return 0

    @staticmethod
    def op(a, b):
        return a + b


def main():
    n, q = map(int, input().split())
    s = SumSegTree(2 * n)
    for t in range(1, q + 1):
        x, y, z = input().split()
        y, z = int(y), int(z)
        if x == 'R':
            pos = (y - t) % (2 * n)
            orig = s.get(pos)
            s.set(pos, orig + z)
        elif x == 'L':
            pos = (2 * n - 1 - y - t) % (2 * n)
            orig = s.get(pos)
            s.set(pos, orig + z)
        else:
            def get(fr, to):
                if fr // (2 * n) != to // (2 * n):
                    return s.prod(fr % (2 * n), 2 * n) + s.prod(0, to % (2 * n))
                else:
                    return s.prod(fr % (2 * n), to % (2 * n))

            print(get(y - t, z - t) + get(2 * n - z - t, 2 * n - y - t))


def _start():
    ret = main()

    if ret is not None:
        if isinstance(ret, List) or isinstance(ret, Tuple):
            print(*ret)
        else:
            print(ret)


if __name__ == '__main__':
    _start()