#include <fstream>
#include <vector>
#include <set>
#include <map>
#include <queue>

using namespace std;

struct Edge {
    int to, c, f;

    Edge(int _to, int _c): to(_to), c(_c), f(0) {}
};

const int MAXN = 4, MAXC = 105, MAXM = 1005, MAXCNT = MAXC + 60 * MAXN,
    gox[] = {-1, -1, 0, 1, 1, 0}, goy[] = {0, 1, 1, 0, -1, -1};
int tx[MAXN], ty[MAXN], hp[MAXN], cx[MAXC], cy[MAXC], v[MAXC],
    mx[MAXM], my[MAXM], tok[MAXN], x[MAXCNT], y[MAXCNT],
    tox[MAXC], toy[MAXC], at[MAXC], w, h, n, c, m, cnt;
char used[MAXCNT];
vector<Edge> e;
vector<int> g[MAXCNT];
set< pair<int, int> > bad;
map<pair<int, int>, int> added;

bool outside(int x, int y) {
    return x < 0 || x >= w || y < 0 || y >= h;
}

void addVertices(int xx, int yy, int &cnt) {
    for(int i = 0; i < 6; i++)
        for(int j = 0; j < 6; j++) {
            int xxx = xx + gox[i] + gox[j], yyy = yy + goy[i] + goy[j];
            if(outside(xxx, yyy) ||
               added.find(make_pair(xxx, yyy)) != added.end())
                continue;
            x[cnt] = xxx;
            y[cnt] = yyy;
            added[make_pair(xxx, yyy)] = cnt;
            cnt++;
            x[cnt] = xxx;
            y[cnt] = yyy;
            cnt++;
        }
}

void addEdge(int v, int u, int cap) {
    g[v].push_back(e.size());
    e.push_back(Edge(u, cap));
    g[u].push_back(e.size());
    e.push_back(Edge(v, 0));
}

void addFlow(int id) {
    e[id].f++;
    e[id ^ 1].f--;
}

void bfs(int sx, int sy, int v, int id) {
    queue< pair<int, int> > q;
    map< pair<int, int>, int> dist;
    q.push(make_pair(sx, sy));
    dist[make_pair(sx, sy)] = 0;
    while(!q.empty()) {
        int vx = q.front().first, vy = q.front().second;
        q.pop();
        if(added.find(make_pair(vx, vy)) != added.end())
            addEdge(id, added[make_pair(vx, vy)], 1);
        int dv = dist[make_pair(vx, vy)];
        if(dv == v)
            continue;
        for(int i = 0; i < 6; i++) {
            int xx = vx + gox[i], yy = vy + goy[i];
            if(outside(xx, yy) || bad.find(make_pair(xx, yy)) != bad.end() ||
               dist.find(make_pair(xx, yy)) != dist.end())
                continue;
            dist[make_pair(xx, yy)] = dv + 1;
            q.push(make_pair(xx, yy));
        }
    }
}

bool dfs(int v, int t) {
    if(v == t)
        return true;
    used[v] = true;
    for(size_t i = 0; i < g[v].size(); i++) {
        int u = e[g[v][i]].to, cf = e[g[v][i]].c - e[g[v][i]].f;
        if(!used[u] && cf > 0 && dfs(u, t)) {
            addFlow(g[v][i]);
            return true;
        }
    }
    return false;
}

int maxFlow(int s, int t, int n) {
    int res = 0;
    while(true) {
        for(int i = 0; i < n; i++)
            used[i] = false;
        if(!dfs(s, t))
            break;
        res++;
    }
    return res;
}

bool solve() {
    cnt = c;
    added.clear();
    for(int i = 0; i < n; i++)
        if(tok[i])
            addVertices(tx[i], ty[i], cnt);
    int tcnt = 0;
    for(int i = 0; i < n; i++)
        if(tok[i])
            tcnt++;
    cnt += tcnt;
    int s = cnt++, t = cnt++;
    e.clear();
    for(int i = 0; i < cnt; i++)
        g[i].clear();
    for(int i = 0; i < c; i++)
        addEdge(s, i, 1);
    for(int i = 0; i < c; i++)
        bfs(cx[i], cy[i], v[i], i);
    for(int i = c; i < cnt - 2 - tcnt; i += 2) {
        addEdge(i, i + 1, 1);
        int tid = cnt - 2 - tcnt;
        for(int j = 0; j < n; j++) {
            if(!tok[j])
                continue;
            bool ok = false;
            for(int d0 = 0; d0 < 6; d0++)
                for(int d1 = 0; d1 < 6; d1++)
                    if(tx[j] + gox[d0] + gox[d1] == x[i] &&
                       ty[j] + goy[d0] + goy[d1] == y[i]) {
                        ok = true;
                        break;
                    }
            if(ok)
                addEdge(i + 1, tid, 1);
            tid++;
        }
    }
    int tid = cnt - 2 - tcnt, sum = 0;
    for(int i = 0; i < n; i++)
        if(tok[i]) {
            addEdge(tid, t, hp[i]);
            sum += hp[i];
            tid++;
        }
    return maxFlow(s, t, cnt) == sum;
}

int main() {
    ifstream in("input.txt");
    ofstream out("output.txt");
    in >> w >> h >> n;
    for(int i = 0; i < n; i++)
        in >> tx[i] >> ty[i] >> hp[i];
    in >> c;
    for(int i = 0; i < c; i++) {
        in >> cx[i] >> cy[i] >> v[i];
        v[i]--;
    }
    in >> m;
    for(int i = 0; i < m; i++)
        in >> mx[i] >> my[i];
    for(int i = 0; i < n; i++)
        bad.insert(make_pair(tx[i], ty[i]));
    for(int i = 0; i < m; i++)
        bad.insert(make_pair(mx[i], my[i]));
    int msk = 0;
    for(int i = 0; i < (1 << n); i++) {
        for(int j = 0; j < n; j++)
            tok[j] = ((i & (1 << j)) > 0);
        if(solve() && __builtin_popcount(msk) < __builtin_popcount(i))
            msk = i;
    }
    for(int i = 0; i < n; i++)
        tok[i] = ((msk & (1 << i)) > 0);
    solve();
    int tcnt = __builtin_popcount(msk);
    out << tcnt << '\n';
    int s = cnt - 2;
    for(size_t i = 0; i < g[s].size(); i++) {
        int cat = e[g[s][i]].to, f = e[g[s][i]].f;
        if(!f) {
            tox[cat] = cx[cat];
            toy[cat] = cy[cat];
            at[cat] = -1;
            continue;
        }
        for(size_t j = 0; j < g[cat].size(); j++) {
            int u = e[g[cat][j]].to, ff = e[g[cat][j]].f;
            if(u != s && ff) {
                tox[cat] = x[u];
                toy[cat] = y[u];
                u++;
                for(size_t k = 0; k < g[u].size(); k++) {
                    int town = e[g[u][k]].to, fff = e[g[u][k]].f;
                    if(town != u - 1 && fff) {
                        at[cat] = town - (cnt - 2 - tcnt);
                        break;
                    }
                }
                break;
            }
        }
    }
    for(int i = 0; i < c; i++)
        for(int j = 0; j < c; j++)
            if(at[j] == -1)
                for(int k = 0; k < c; k++)
                    if(k != j && tox[k] == cx[j] && toy[k] == cy[j]) {
                        at[j] = at[k];
                        tox[k] = cx[k];
                        toy[k] = cy[k];
                        at[k] = -1;
                        break;
                    }
    for(int i = 0; i < c; i++)
        out << tox[i] << ' ' << toy[i] << ' ' << at[i] + 1 << '\n';
    return 0;
}