Problem: The city of Kyoto is well-known for its Chinese plan: streets are either North-South or East-West. Some streets are numbered, but most of them have real names.
Crossings are named after the two streets crossing there, e.g. Kawaramachi-Sanjo is the crossing of Kawaramachi street and Sanjo street. But there is a problem: which name should come first? At first the order seems quite arbitrary: one says Kawaramachi-Sanjo (North-South first) but Shijo-Kawaramachi (East-West first). With some experience, one realizes that actually there seems to be an "order" on the streets, for instance in the above Shijo is "stronger" than Kawaramachi, which in turn is "stronger" than Sanjo. One can use this order to deduce the names of other crossings.

You are given as input a list of known crossing names X-Y. Streets are either North-South or East-West, and only orthogonal streets may cross.

As your list is very incomplete, you start by completing it using the following rule:

* two streets A and B have equal strength if (1) to (3) are all true:
1. they both cross the same third street C in the input
2. there is no street D such that D-A and B-D appear in the input
3. there is no street E such that A-E and E-B appear in the input



We use this definition to extend our strength relation:

* A is stronger than B, when there is a sequence A = A1, A2, ..., An = B, with n at least 2,
where, for any i in 1 .. n-1, either Ai-Ai+1 is an input crossing or Ai and Ai+1 have equal strength.



Then you are asked whether some other possible crossing names X-Y are valid. You should answer affirmatively if you can infer the validity of a name, negatively if you cannot. Concretely:

* YES if you can infer that the two streets are orthogonal, and X is stronger than Y
* NO otherwise



Input

The input is a sequence of data sets, each of the form

>
>     N
>     Crossing1
>     ...
>     CrossingN
>     M
>     Question1
>     ...
>     QuestionM
>

Both Crossings and Questions are of the form

> X-Y

where X and Y are strings of alphanumerical characters, of lengths no more than 16. There is no white space, and case matters for alphabetical characters.
N and M are between 1 and 1000 inclusive, and there are no more than 200 streets in a data set.

The last data set is followed by a line containing a zero.

Output

The output for each data set should be composed of M+1 lines, the first one containing the number of streets in the Crossing part of the input, followed by the answers to each question, either YES or NO without any spaces.

Example

Input

7
Shijo-Kawaramachi
Karasuma-Imadegawa
Kawaramachi-Imadegawa
Nishioji-Shijo
Karasuma-Gojo
Torimaru-Rokujo
Rokujo-Karasuma
6
Shijo-Karasuma
Imadegawa-Nishioji
Nishioji-Gojo
Shijo-Torimaru
Torimaru-Gojo
Shijo-Kawabata
4
1jo-Midosuji
Midosuji-2jo
2jo-Omotesando
Omotesando-1jo
4
Midosuji-1jo
1jo-Midosuji
Midosuji-Omotesando
1jo-1jo
0


Output

8
YES
NO
YES
NO
YES
NO
4
YES
YES
NO
NO

Solution (in CPP):

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

constexpr int inf = 1e9;

class quick_find {
public:
    quick_find(int n) : par(n, -1), cmp(n) {
        for(int i = 0; i < n; ++i) {
            cmp[i].push_back(i);
        }
    }

    int root(int x) {
        return par[x] < 0 ? x : par[x] = root(par[x]);
    }

    bool unite(int x, int y) {
        x = root(x), y = root(y);
        if(x == y) return false;
        if(cmp[x].size() > cmp[y].size()) swap(x, y);
        for(auto v : cmp[y]) {
            cmp[x].push_back(v);
        }
        cmp[y].clear();
        par[y] = x;
        return true;
    }

    std::vector<int> component(int v) {
        return cmp[root(v)];
    }

    bool same(int x, int y) {
        return root(x) == root(y);
    }

    int size(int v) {
        return cmp[root(v)].size();
    }

private:
    std::vector<int> par;
    std::vector<std::vector<int>> cmp;
};

pair<string, string> split(string cross) {
    int sp = cross.find('-');
    return {cross.substr(0, sp), cross.substr(sp + 1)};
}

int main() {
    int N;
    while(cin >> N, N) {
        vector<vector<int>> g(2 * N), rg(2 * N), g2(2 * N);
        map<string, int> idx;
        for(int i = 0; i < N; ++i) {
            string cross;
            cin >> cross;
            string s, t;
            tie(s, t) = split(cross);
            if(idx.count(s) == 0) {
                const int nid = idx.size();
                idx[s] = nid;
            }
            if(idx.count(t) == 0) {
                const int nid = idx.size();
                idx[t] = nid;
            }
            g[idx[s]].push_back(idx[t]);
            rg[idx[t]].push_back(idx[s]);
            g2[idx[s]].push_back(idx[t]);
            g2[idx[t]].push_back(idx[s]);
        }

        N = idx.size();
        cout << N << endl;

        quick_find qf(N);
        vector<vector<bool>> can_go(N, vector<bool>(N));
        vector<int> dir(N, -1);
        function<void(int, int)> dfs = [&](int root, int v) {
            if(can_go[root][v]) return;
            can_go[root][v] = true;
            for(auto to : g[v]) {
                dfs(root, to);
            }
        };
        for(int i = 0; i < N; ++i) {
            dfs(i, i);
        }
        for(int i = 0; i < N; ++i) {
            for(auto j = 0; j < (int)g[i].size(); ++j) {
                for(int k = j + 1; k < (int)g[i].size(); ++k) {
                    int v1 = g[i][j], v2 = g[i][k];
                    if(!can_go[v1][v2] && !can_go[v2][v1]) {
                        qf.unite(v1, v2);
                    }
                }
            }
            for(int j = 0; j < (int)rg[i].size(); ++j) {
                for(int k = j + 1; k < (int)rg[i].size(); ++k) {
                    int v1 = rg[i][j], v2 = rg[i][k];
                    if(!can_go[v1][v2] && !can_go[v2][v1]) {
                        qf.unite(v1, v2);
                    }
                }
            }
        }
        
        can_go = vector<vector<bool>>(N, vector<bool>(N));
        for(int i = 0; i < N; ++i) {
            auto now = qf.component(i);
            for(auto from : now) {
                for(auto to : g[from]) {
                    if(can_go[i][to]) continue;
                    auto cmp = qf.component(to);
                    for(auto to2 : cmp) {
                        can_go[i][to2] = true;
                    }
                }
            }
        }
        for(int k = 0; k < N; ++k) {
            for(int i = 0; i < N; ++i) {
                for(int j = 0; j < N; ++j) {
                    can_go[i][j] = can_go[i][j] | (can_go[i][k] && can_go[k][j]);
                }
            }
        }
        function<void(int, int, int)> dfs2 = [&](int v, int p, int d) {
            if(dir[v] != -1) return;
            dir[v] = d;
            for(auto to : g2[v]) {
                if(to == p) continue;
                dfs2(to, v, d ^ 1);
            }
        };
        for(int i = 0; i < N; ++i) {
            dfs2(i, -1, 0);
        }

        int M;
        cin >> M;
        while(M--) {
            string query;
            cin >> query;
            string s, t;
            tie(s, t) = split(query);
            if(s == t || idx.count(s) == 0 || idx.count(t) == 0) {
                cout << "NO" << endl;
            } else {
                int si = idx[s], ti = idx[t];
                if(dir[si] == dir[ti]) {
                    cout << "NO" << endl;
                } else {
                    if(can_go[si][ti]) {
                        cout << "YES" << endl;
                    } else {
                        cout << "NO" << endl;
                    }
                }
            }
        }
    }
}