// URL: https://yukicoder.me/problems/no/151

import std.algorithm, std.array, std.container, std.math, std.range, std.typecons, std.string;

version(unittest) {} else
void main()
{
  int N, Q; io.getV(N, Q);

  auto n = N*2, ft = new FenwickTree!long(n);
  foreach (t; 0..Q) {
    string x; int y, z; io.getV(x, y, z);
    switch (x) {
    case "L":
      ft[(y+t)%n] += z;
      break;
    case "R":
      ft[(n-1-y+t)%n] += z;
      break;
    case "C":
      auto r = 0L;
      auto u1 = (y+t)%n, v1 = (z-1+t)%n+1;
      r += u1 < v1 ? ft[u1..v1] : ft[0..v1]+ft[u1..n];
      auto u2 = (n-y+t-1)%n+1, v2 = (n-z+t)%n;
      r += v2 < u2 ? ft[v2..u2] : ft[0..u2]+ft[v2..n];
      io.put(r);
      break;
    default:
      assert(0);
    }
  }
}

class FenwickTree(T)
{
  const size_t n;

  this(size_t n) { this.n = n; this.buf = new T[](n+1); }

  void opIndexOpAssign(string op)(T val, size_t i) if (op=="+"||op=="-")
  { ++i; for (; i <= n; i += i&-i) mixin("buf[i]"~op~"=val;"); }

  void opIndexUnary(string op)(size_t i) if (op=="++"||op=="--")
  { ++i; for (; i <= n; i += i&-i) mixin(op~"buf[i];"); }

  pure T opIndex(size_t i) { return opSlice(i, i+1); }
  pure T opSlice(size_t r, size_t l) { return get(l) - get(r); }
  pure size_t opDollar() { return n; }

  private
  {
    T[] buf;

    pure T get(size_t i)
    {
      auto s = T(0);
      for (; i > 0; i -= i & -i) s += buf[i];
      return s;
    }
  }
}
FenwickTree!T fenwickTree(T)(size_t n) { return new FenwickTree!T(n); }

auto io = IO!()();
import std.stdio;
struct IO(string floatFormat = "%.10f", string delimiter = " ", alias IN = stdin, alias OUT = stdout)
{
  import std.conv, std.format, std.meta, std.traits;
  alias assignable = hasAssignableElements;

  auto getV(T...)(ref T v) { foreach (ref w; v) get(w); }
  auto getA(T)(size_t n, ref T v) if (assignable!T) { v = new T(n); foreach (ref w; v) get(w); }
  auto getC(T...)(size_t n, ref T v) if (allSatisfy!(assignable, T))
  {
    foreach (ref w; v) w = new typeof(w)(n);
    foreach (i; 0..n) foreach (ref w; v) get(w[i]);
  }
  auto getM(T)(size_t r, size_t c, ref T v) if (assignable!T && assignable!(ElementType!T))
  {
    v = new T(r); foreach (ref w; v) getA(c, w);
  }

  auto put(bool flush = false, T...)(T v)
  {
    foreach (i, w; v) { putA(w); if (i < v.length-1) OUT.write(delimiter); }
    OUT.writeln;
    static if (flush) OUT.flush();
  }
  auto putB(S, T)(bool c, S t, T f) { if (c) put(t); else put(f); }
  auto putRaw(T...)(T v) { OUT.write(v); OUT.writeln; }

  private
  {
    dchar[] buf;
    auto sp = (new dchar[](0)).splitter;
    void nextLine() { IN.readln(buf); sp = buf.splitter; }
    auto get(T)(ref T v) { if (sp.empty) nextLine(); v = sp.front.to!T; sp.popFront(); }

    auto putR(T)(T v)
    {
      auto w = v;
      while (!w.empty) { putA(w.front); w.popFront(); if (!w.empty) OUT.write(delimiter); }
    }
    auto putA(T)(T v)
    {
      static if (isInputRange!T && !isSomeString!T) putR(v);
      else if (isFloatingPoint!T) OUT.write(format(floatFormat, v));
      else OUT.write(v);
    }
  }
}