#include <bits/stdc++.h>
using namespace std;
const int ms = 4e5 + 5, inf = 0x3f3f3f3f;
map<int, int> tipo;
map<int, int> pos;
int inicioIdx[ms], sz[ms];
int seg[2 * ms], lazy[2 * ms];
int ciclo[ms], posicaoNoCiclo[ms];
int n;
int h;
int *t, *d;
void calc(int p, int k) {
  if (d[p] == -1)
    t[p] = max(t[p << 1], t[p << 1 | 1]);
  else
    t[p] = d[p];
}
void apply(int p, int value, int k) {
  t[p] = value;
  if (p < n) d[p] = value;
}
void build(int l, int r) {
  int k = 2;
  for (l += n, r += n - 1; l > 1; k <<= 1) {
    l >>= 1, r >>= 1;
    for (int i = r; i >= l; --i) calc(i, k);
  }
}
void push(int l, int r) {
  int s = h, k = 1 << (h - 1);
  for (l += n, r += n - 1; s > 0; --s, k >>= 1)
    for (int i = l >> s; i <= r >> s; ++i)
      if (d[i] != -1) {
        apply(i << 1, d[i], k);
        apply(i << 1 | 1, d[i], k);
        d[i] = -1;
      }
}
void modify(int l, int r, int value) {
  if (value == -1) return;
  r++;
  push(l, l + 1);
  push(r - 1, r);
  int l0 = l, r0 = r, k = 1;
  for (l += n, r += n; l < r; l >>= 1, r >>= 1, k <<= 1) {
    if (l & 1) apply(l++, value, k);
    if (r & 1) apply(--r, value, k);
  }
  build(l0, l0 + 1);
  build(r0 - 1, r0);
}
int query(int l) {
  push(l, l + 1);
  return t[n + l];
}
void updateGlobal(int i) {
  d = lazy + inicioIdx[i];
  t = seg + inicioIdx[i];
  n = sz[i];
  h = sizeof(int) * 8 - __builtin_clz(n);
}
int buscaBinaria(int t, int p) {
  int n = sz[t];
  updateGlobal(t);
  int l = p + 1, r = p + n;
  while (r - l > 1) {
    int m = (l + r) / 2;
    int check = query(m % n);
    if (check == p)
      r = m;
    else
      l = m;
  }
  int check = query(l % n);
  if (check == p) {
    return l % n;
  } else {
    return r % n;
  }
}
int main() {
  cin.tie(0);
  cin.sync_with_stdio(false);
  int h, m, n, ans = 0;
  cin >> h >> m >> n;
  int zzz = 0;
  int ciclosAteAgora = 0;
  int cnt = 0;
  for (int i = 0; i < h; i++) {
    int pos = i;
    if (!ciclo[pos]) ++ciclosAteAgora;
    for (int j = 0; ciclo[pos] == 0; j++) {
      ciclo[pos] = ciclosAteAgora;
      posicaoNoCiclo[pos] = j;
      sz[ciclosAteAgora]++;
      cnt++;
      pos = (pos + m) % h;
    }
  }
  for (int i = 1; i <= ciclosAteAgora; i++) {
    int qnt = sz[i];
    inicioIdx[i] = zzz;
    updateGlobal(i);
    for (int j = 0; j < qnt; j++) d[j] = -1;
    for (int j = 0; j < qnt; j++) modify(j, j, j);
    zzz += 2 * qnt;
  }
  for (int i = 0; i < n; i++) {
    string s;
    cin >> s;
    if (s == "+") {
      int hash, id;
      cin >> id >> hash;
      int t = ciclo[hash], p = posicaoNoCiclo[hash];
      updateGlobal(t);
      int posicaoInserir = query(p);
      pos[id] = posicaoInserir;
      tipo[id] = t;
      ans += (posicaoInserir + sz[t] - p) % sz[t];
      int apos = query((posicaoInserir + 1) % sz[t]);
      if (apos == posicaoInserir) {
        modify(0, sz[t] - 1, inf);
        continue;
      }
      int inicioUpdate = buscaBinaria(t, posicaoInserir);
      if (inicioUpdate > posicaoInserir) {
        modify(inicioUpdate, sz[t] - 1, apos);
        modify(0, posicaoInserir, apos);
      } else {
        modify(inicioUpdate, posicaoInserir, apos);
      }
    } else {
      int id;
      cin >> id;
      int t = tipo[id], p = pos[id];
      updateGlobal(t);
      int posicaoApos = query(p);
      if (posicaoApos == inf) {
        modify(0, sz[t] - 1, p);
        continue;
      }
      int inicioUpdate = buscaBinaria(t, posicaoApos);
      if (inicioUpdate > p) {
        modify(inicioUpdate, sz[t] - 1, p);
        modify(0, p, p);
      } else {
        modify(inicioUpdate, p, p);
      }
    }
  }
  cout << ans << '\n';
  return 0;
}
