#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;
                    }
                }
            }
        }
    }
}


Measured memory_bytes: 3320