#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ull = unsigned long long;
using ld = long double;
const ll llinf = (1ll << 61) - 1;
const double eps = 1e-6, ldeps = 1e-9;
struct Dbg {
  static constexpr auto &os = cout;
  template <class C>
  static auto dud(C *x) -> decltype(os << *x, 0);
  template <class C>
  static char dud(...);
  template <class C>
  typename enable_if<sizeof dud<C>(0) != 1, Dbg &>::type operator<<(
      const C &x) {
    os << x;
    return *this;
  }
  template <class C>
  Dbg &dump(C b, C e) {
    *this << "\n[";
    int cur = 0;
    for (C i = b; i != e and cur < 26; i++, cur++)
      *this << ", " + 2 * (i == b) << *i;
    return *this << ']';
  }
  template <class C>
  typename enable_if<sizeof dud<C>(0) == 1, Dbg &>::type operator<<(
      const C &x) {
    return dump(begin(x), end(x));
  }
  template <class C, size_t X>
  typename enable_if<sizeof(C) != 1, Dbg &>::type operator<<(C (&x)[X]) {
    return dump(begin(x), end(x));
  }
  template <class B, class C>
  Dbg &operator<<(const pair<B, C> &x) {
    return *this << '{' << x.first << ", " << x.second << '}';
  }
  template <class C, size_t Y>
  struct TP {
    void operator()(Dbg &os, const C &t) {
      TP<C, Y - 1>()(os, t);
      os << ", " << get<Y - 1>(t);
    }
  };
  template <class C>
  struct TP<C, 1> {
    void operator()(Dbg &os, const C &t) { os << get<0>(t); }
  };
  template <class... C>
  Dbg &operator<<(const tuple<C...> &t) {
    os << '{', TP<decltype(t), sizeof...(C)>()(*this, t);
    return *this << '}';
  }
  Dbg &operator<<(ostream &(*x)(std::ostream &)) {
    os << x;
    return *this;
  }
} dbg;
void err(istringstream *iss) { delete iss; }
template <class C, class... Args>
void err(istringstream *iss, const C &val, const Args &...args) {
  string name;
  *iss >> name;
  if (name.back() == ',') name.pop_back();
  dbg << name << " = " << val << "; ", err(iss, args...);
}
int T, Q, cn;
const int inf = 1000000007, mxn = 2005, mxq = 1000005;
template <class T, int R, int C>
class BIT2D {
 public:
  int mnr, mnc;
  T tree[R + 2][C + 2];
  void reset() { memset(tree, 0, sizeof(tree)); }
  BIT2D(int _mnr = 0, int _mnc = 0) : mnr(_mnr), mnc(_mnc) { reset(); }
  void addAtIdx(int r, int c, T val) {
    r += 1 - mnr, c += 1 - mnc;
    while (r <= R) {
      int _c = c;
      while (_c <= C) tree[r][_c] += val, _c += (_c & -_c);
      r += (r & -r);
    }
  }
  T getPrefixSum(int r, int c) {
    r += 1 - mnr, c += 1 - mnc;
    T sum = 0;
    while (r > 0) {
      int _c = c;
      while (_c > 0) sum += tree[r][_c], _c -= (_c & -_c);
      r -= (r & -r);
    }
    return sum;
  }
  T getRectangleSum(int r1, int c1, int r2, int c2) {
    return getPrefixSum(r2, c2) - getPrefixSum(r2, c1 - 1) -
           getPrefixSum(r1 - 1, c2) + getPrefixSum(r1 - 1, c1 - 1);
  }
  void addRange(int r1, int c1, int r2, int c2, T val) {
    addAtIdx(r1, c1, val), addAtIdx(r1, c2 + 1, -val),
        addAtIdx(r2 + 1, c1, -val), addAtIdx(r2 + 1, c2 + 1, val);
  }
};
int n, m, K, q2i;
BIT2D<ll, mxn, mxn> ft;
vector<pair<pair<int, int>, int> > garlands[mxn];
struct Query {
  int t, x1, y1, x2, y2;
} q[mxq], q2[mxn];
ll pre[mxn][mxn];
bitset<mxn> off;
signed main() {
  ios::sync_with_stdio(0);
  cin.tie(NULL);
  cout.precision(11);
  cin >> n >> m >> K;
  for (int i = 0; i < K; i++) {
    int len;
    cin >> len;
    garlands[i].resize(len);
    for (int j = 0; j < len; j++) {
      int x, y, w;
      cin >> x >> y >> w, garlands[i][j] = {{x, y}, w};
    }
  }
  cin >> Q;
  for (int i = 0; i < Q; i++) {
    string s;
    cin >> s;
    if (s == "SWITCH") {
      cin >> q[i].x1;
    } else {
      cin >> q[i].x1 >> q[i].y1 >> q[i].x2 >> q[i].y2;
      q2[q2i++] = q[i];
      q[i].t = q2i;
    }
  }
  for (int i = 0; i < K; i++) {
    for (auto &j : garlands[i]) {
      ft.addAtIdx(j.first.first, j.first.second, j.second);
    }
    for (int j = 0; j < q2i; j++) {
      pre[i][j] = ft.getRectangleSum(q2[j].x1, q2[j].y1, q2[j].x2, q2[j].y2);
    }
    for (auto &j : garlands[i]) {
      ft.addAtIdx(j.first.first, j.first.second, -j.second);
    }
  }
  for (int i = 0; i < Q; i++) {
    if (!q[i].t) {
      off[q[i].x1 - 1] = !off[q[i].x1 - 1];
      continue;
    }
    ll ans = 0;
    for (int j = 0; j < K; j++) {
      if (!off[j]) ans += pre[j][q[i].t - 1];
    }
    cout << ans << '\n';
  }
}
