// Words are flowing out like endless rain into a paper cup
// They slither while they pass they slip away across the universe
// Pools of sorrow, waves of joy are drifting through my open mind
// Possessing and caressing me

#include <bits/stdc++.h>
using namespace std;

using i64 = long long;

namespace _buff {

const size_t BUFF = 1 << 19;
char ibuf[BUFF], *ib = ibuf, *ie = ibuf;
char getc() {
    if (ib == ie) {
        ib = ibuf;
        ie = ibuf + fread(ibuf, 1, BUFF, stdin);
    }
    return ib == ie ? -1 : *ib++;
}

}

i64 read() {
    using namespace _buff;
    i64 ret = 0;
    bool pos = true;
    char c = getc();
    for (; (c < '0' || c > '9') && c != '-'; c = getc()) {
        assert(~c);
    }
    if (c == '-') {
        pos = false;
        c = getc();
    }
    for (; c >= '0' && c <= '9'; c = getc()) {
        ret = (ret << 3) + (ret << 1) + (c ^ 48);
    }
    return pos ? ret : -ret;
}

template <typename T>
bool chkmin(T &dp, const T &val) {
    return val < dp ? (dp = val, true) : false;
}

template <typename T>
bool chkmax(T &dp, const T &val) {
    return val > dp ? (dp = val, true) : false;
}

const size_t N = 14;
const size_t M = 105;

struct Coor {
    int x, y;
    Coor() {}
    void input() { x = read(); y = read(); }
} tow[N];

struct Quest {
    Coor co; int t;
    bool operator < (const Quest &q) const {
        return t < q.t;
    }
} que[M];

int dis(Coor c1, Coor c2) {
    return abs(c1.x - c2.x) + abs(c1.y - c2.y);
}

int dis_q[1 << N][M], dis_t[1 << N][N];
int f[1 << N][M], g[1 << N][M];

int main() {
    memset(dis_q, 0x3f, sizeof dis_q);
    memset(dis_t, 0x3f, sizeof dis_t);
    memset(f, 0xef, sizeof f);
    memset(g, 0x3f, sizeof g);

    int n = read(), m = read();
    for (int i = 0; i < n; ++i) {
        tow[i].input();
    }
    for (int i = 0; i < m; ++i) {
        que[i].co.input();
        que[i].t = read();
    }
    sort(que, que + m);

    int _ = 1 << n;
    for (int i = 0; i < _; ++i) {
        for (int j = 0; j < m; ++j) {
            for (int k = 0; k < n; ++k) {
                if (i >> k & 1) {
                    chkmin(dis_q[i][j], dis(tow[k], que[j].co));
                }
            }
        }
        for (int j = 0; j < n; ++j) {
            for (int k = 0; k < n; ++k) {
                if (i >> k & 1) {
                    chkmin(dis_t[i][j], dis(tow[k], tow[j]));
                }
            }
        }
    }

    for (int i = 0; i < _; ++i) {
        if (__builtin_popcount(i) < 2) {
            g[i][0] = 0;
        }
    }
    for (int i = 0; i < m; ++i) {
        f[0][i] = 1;
    }
    for (int i = 0; i < _; ++i) {
        // cerr << "i = " << i << '\n';
        for (int j = 0; j < m; ++j) {
            for (int k = 0; k < m; ++k) {
                if (g[i][j] + dis_q[i][k] <= que[k].t) {
                    chkmax(f[i][k], j + 1);
                }
            }
        }
        // cerr << "f = "; for (int j = 0; j < m; ++j) cerr << f[i][j] << ' '; cerr << '\n';
        for (int j = 0; j < m; ++j) {
            for (int k = j + 1; k < m; ++k) {
                if (que[j].t + min(dis(que[j].co, que[k].co), dis_q[i][k]) <= que[k].t) {
                    chkmax(f[i][k], f[i][j] + 1);
                }
            }
        }
        for (int j = 0; j < m; ++j) {
            if (f[i][j] >= 0) {
                chkmin(g[i][f[i][j]], que[j].t);
                for (int k = 0; k < n; ++k) {
                    if (~i >> k & 1) {
                        chkmin(g[i | (1 << k)][f[i][j]], que[j].t + min(dis(que[j].co, tow[k]), dis_t[i][k]));
                    }
                }
            }
        }
        for (int j = 0; j <= m; ++j) {
            for (int k = 0; k < n; ++k) {
                if (~i >> k & 1) {
                    chkmin(g[i | (1 << k)][j], g[i][j] + dis_t[i][k]);
                }
            }
        }
        // cerr << "f = "; for (int j = 0; j < m; ++j) cerr << f[i][j] << ' '; cerr << '\n';
        // cerr << "g = "; for (int j = 0; j <= m; ++j) cerr << g[i][j] << ' '; cerr << '\n';
        // cerr << '\n';
    }
    int ans = 0;
    for (int i = 0; i < _; ++i) {
        ans = max(*max_element(f[i], f[i] + m), ans);
    }
    cout << ans << '\n';
    return 0;
}