#include <bits/stdc++.h>

#define FOR(i, l, r) for (int i = l; i < (r); ++i)
#define F0R(i, r) FOR (i, 0, r)
#define ROF(i, l, r) for (int i = r; i-- > (l);)
#define R0F(i, r) ROF (i, 0, r)
#define rep(n) F0R (_, n)
#define each(i, x) for (auto& i : x)

using namespace std;

using ll = long long;
using db = long double;
using str = string;

using pi = pair<int, int>;
#define mp make_pair
#define f first
#define s second

#define ttt template <typename T
ttt > using vec = vector<T>;
ttt, size_t n > using arr = array<T, n>;
using vi = vec<int>;
using vb = vec<bool>;
using vl = vec<ll>;
using vpi = vec<pi>;
#define sz(x) int((x).size())
#define all(x) begin(x), end(x)
#define rsz resize
#define pb push_back
#define eb emplace_back

#define il inline
ttt > il bool ckmin(T& x, const T& y) { return y < x ? x = y, true : false; }
ttt > il bool ckmax(T& x, const T& y) { return x < y ? x = y, true : false; }

struct Node {
  int sz, lsz, mx, p, l, r;
};
struct Lct {
  vec<Node> t;
  Lct(int n) : t(n + 1) {}

  bool not_rt(int o) const { return o == t[t[o].p].l || o == t[t[o].p].r; }
  void pull(int o) {
    t[o].sz = t[o].lsz + t[t[o].l].sz + t[t[o].r].sz;
    t[o].mx = max({o, t[t[o].l].mx, t[t[o].r].mx});
  }
  void rot(int o) {
    int& p = t[o].p;
    Node &x = t[o], &y = t[p];
    if (o == y.l)
      t[x.r].p = p, y.l = x.r, x.r = p;
    else
      t[x.l].p = p, y.r = x.l, x.l = p;
    if (not_rt(p)) (p == t[y.p].l ? t[y.p].l : t[y.p].r) = o;
    pull(p), pull(o), p = y.p, y.p = o;
  }
  void splay(int o) {
    for (; not_rt(o); rot(o)) {
      int p = t[o].p;
      if (not_rt(p)) rot((o == t[p].l) == (p == t[t[p].p].l) ? p : o);
    }
  }
  int access(int o) {
    int p = 0;
    for (; o; p = o, o = t[o].p)
      t[o].lsz += t[p].sz - t[t[o].r].sz, t[o].r = p, pull(o);
    return p;
  }
  int split(int o, int v) {
    int p = -1, q = 0;
    while (o) {
      q = o;
      if (o >= v)
        p = o, o = t[o].r;
      else
        o = t[o].l;
    }
    return splay(q), splay(p), p;
  }
  void unite(int o1, int o2) {
    access(o1);
    int p = access(o2);
    if (o1 == p || o2 == p) return;
    access(p), splay(o1), splay(o2);
    p = 0;
    while (o1 || o2) {
      if (t[o1].mx < t[o2].mx) swap(o1, o2);
      o1 = split(o1, t[o2].mx);
      if (p) t[p].r = o1, t[o1].p = p, pull(p);
      splay(p = o1);
      int q = t[o1].r;
      if (q) t[o1].r = t[q].p = 0, pull(o1);
      o1 = q;
    }
  }
  int qry(int o, int v) {
    access(o), splay(o);
    int ans = 0, p = 0;
    while (o) {
      p = o;
      if (o <= v)
        ans += t[o].lsz + t[t[o].r].sz, o = t[o].l;
      else
        o = t[o].r;
    }
    return splay(p), ans;
  }
};

int main() {
  cin.tie(nullptr)->sync_with_stdio(false), cin.exceptions(cin.failbit);

  int t, n, q;
  cin >> t >> n >> q;

  Lct lct(n + 1);
  FOR (i, 1, n + 1) lct.t[i] = {1, 1, i, n + 1};
  lct.t[n + 1] = {n, n, n + 1};

  int ans = 0;
  rep (q) {
    int type, x, y;
    cin >> type >> x >> y;
    x = (x - 1 + t * ans) % n + 1, y = (y - 1 + t * ans) % n + 1;
    if (type == 1)
      lct.unite(x, y);
    else
      cout << (ans = lct.qry(x, y)) << "\n";
  }
}