#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<queue>
#include<set>

#define lc(x) ns[x].l
#define rc(x) ns[x].r

using namespace std;

typedef long long ll;
typedef unsigned long long ull;

struct io_s {

    bool negative;
    char ch;

    inline bool isdigitx(char c) {
        return c >= '0' && c <= '9';
    }

    template<typename T>
    bool rn(T& _v) {
        negative = false;
        _v = 0;
        while (!isdigitx(ch = getchar()) && ch != EOF) { negative = ch == '-'; };
        if (ch == EOF)return false;
        do { _v = _v * 10 + ch - '0'; } while (isdigitx(ch = getchar()));
        if (negative) _v = -_v;
        return true;
    }

    template<typename T>
    bool run(T& _v) {
        _v = 0;
        while (!isdigitx(ch = getchar()) && ch != EOF) {};
        if (ch == EOF)return false;
        do { _v = _v * 10 + ch - '0'; } while (isdigitx(ch = getchar()));
        return true;
    }

    template<typename T>
    inline T r() {
        T v = T();
        rn(v);
        return v;
    }

    inline int ri() { return r<int>(); }
    inline ll rll() { return r<ll>(); }

    template<class T>
    inline void o(T p) {
        static int stk[70], tp;
        if (p == 0) { putchar('0'); return; }
        if (p < 0) { p = -p; putchar('-'); }
        while (p) stk[++tp] = p % 10, p /= 10;
        while (tp) putchar(stk[tp--] + '0');
    }
    inline void ln() { putchar('\n'); }

    inline void space() { putchar(' '); }

    template<class T>
    inline void oln(T p) {
        o(p); ln();
    }

} io;

const int inf = 100000000;

int n, m;
struct P {
    int x, y;
}a[505], b[505];
int dis[505][505];
ll operator*(P a, P b)
{
    return 1LL * a.x*b.y - 1LL * a.y*b.x;
}
P operator-(P a, P b)
{
    P t; t.x = a.x - b.x; t.y = a.y - b.y; return t;
}
bool col(P x, P y)
{
    if (x.x > y.x)swap(x, y);
    for (int i = 1; i <= m; i++)
        if (b[i].x<x.x || b[i].x>y.x)
            return 0;
    if (x.y > y.y)swap(x, y);
    for (int i = 1; i <= m; i++)
        if (b[i].y<x.y || b[i].y>y.y)
            return 0;
    return 1;
}
int jud(P x, P y)
{
    int c1 = 0, c2 = 0;
    for (int i = 1; i <= m; i++)
    {
        ll t = (y - x)*(b[i] - x);
        if (t > 0)c1++;
        if (t < 0)c2++;
        if (c1*c2)return 0;
    }
    if (!c1 && !c2&&col(x, y)) { io.oln(n - 2); return -1; }
    if (c1) return 1;
    if (c2) return 2;
    return 3;
}

void floyd()
{
    int ans = inf;
    for (int k = 1; k <= n; k++)
        for (int i = 1; i <= n; i++)
            if (dis[i][k] < inf)
                for (int j = 1; j <= n; j++)
                    dis[i][j] = min(dis[i][j], dis[i][k] + dis[k][j]);
    for (int i = 1; i <= n; i++)ans = min(ans, dis[i][i]);
    if (ans == inf || ans <= 2)puts("ToT");
    else io.oln(n - ans);
}
void solve()
{
    for (int i = 1; i <= n; i++)
        for (int j = i + 1; j <= n; j++)
        {
            int flag = jud(a[i], a[j]);
            if (flag == -1)return;
            if (flag == 1)dis[i][j] = 1;
            else if (flag == 2)dis[j][i] = 1;
            //else if (flag == 3)dis[i][j] = dis[j][i] = 1;
        }
    floyd();
}
int main()
{
    while (io.rn(m)) {
        memset(dis, 127 / 3, sizeof(dis));
        for (int i = 1; i <= m; i++)
            io.rn(b[i].x), io.rn(b[i].y);
        io.rn(n);
        for (int i = 1; i <= n; i++)
            io.rn(a[i].x), io.rn(a[i].y);
        if (n == 1 && m == 1) {
            if (b[1].x != a[1].x || b[1].y != a[1].y) { puts("ToT"); continue; }
            puts("0"); continue;
        }
        if (n == 1) {
            puts("ToT"); continue;
        }
        if (m == 1) {
            bool flag = false;
            for (int i = 1; i <= n; ++i) if (a[i].x == b[1].x && a[i].y == b[1].y) {
                flag = true;
                io.oln(n - 1);
            }
            if (flag)continue;
        }
        solve();
    }
    return 0;
}