#include <iostream>
#include <sstream>
#include <fstream>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <algorithm>
#include <numeric>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <climits>
#include <cmath>
using namespace std;

typedef string Vertex;
typedef pair<Vertex, Vertex> PVV;
typedef map <Vertex, int> Index;

const int inf = 1<<24;
const int size = 201;
Index ID;
int N;

bool F[size][size];
bool D[size][size];
bool W[size][size];
int  T[size][size];

void init() {
    ID.clear();
    N = 0;
    for ( int i = 0; i < size; i++ ) {
        for ( int j = 0; j < size; j++ ) {
            F[i][j] = false;
            D[i][j] = false;
            W[i][j] = false;
            T[i][j] = inf;
        }
    }
}

bool exist( Vertex v ) {
    return ID.find(v) != ID.end();
}

void addVertex( Vertex v ) {
    if ( exist( v ) ) return;
    ID[v] = N++;
}

int getIndex( Vertex v ) {
    return ID[v];
}

PVV input() {
    string line;
    cin >> line;
    replace( line.begin(), line.end(), '-', ' ' );
    istringstream is( line );
    PVV answer;
    is >> answer.first >> answer.second;
    return answer;
}

bool solve( PVV e ) {
    if ( !exist(e.first) || !exist(e.second) ) return false;
    int a = getIndex( e.first );
    int b = getIndex( e.second );
    return W[a][b] && ( T[a][b] != inf && T[a][b]%2 );
}

bool check( int a, int b ) {
    if ( a == b ) return false;
    bool flag = false;
    for ( int i = 0; i < N; i++ ) {
        if ( ( F[a][i] && F[b][i] ) || ( F[i][a] && F[i][b] ) ) {
            flag = true;
        }
        if ( ( F[a][i] && F[i][b] ) || ( F[i][a] && F[b][i] ) ) {
            return false;
        }
    }
    return flag;
}

int main() {
    int n;
    while ( cin >> n && n ) {
        init();
        for ( int i = 0; i < n; i++ ) {
            PVV in = input();
            addVertex(in.first);
            addVertex(in.second);
            int a = getIndex(in.first);
            int b = getIndex(in.second);
            F[a][b] = true;
        }
        for ( int i = 0; i < N; i++ ) {
            for ( int j = 0; j < N; j++ ) {
                D[i][j] = check( i, j );
            }
        }
        for ( int i = 0; i < N; i++ ) {
            for ( int j = 0; j < N; j++ ) {
                W[i][j] = F[i][j] || D[i][j];
            }
        }
        for ( int k = 0; k < N; k++ ) {
            for ( int i = 0; i < N; i++ ) {
                for ( int j = 0; j < N; j++ ) {
                    W[i][j] = W[i][j] || ( W[i][k] && W[k][j] );
                }
            }
        }
        for ( int i = 0; i < N; i++ ) {
            for ( int j = 0; j < N; j++ ) {
                if ( F[i][j] ) T[i][j] = 1;
                else if ( D[i][j] ) T[i][j] = T[j][i] = 0;
            }
        }
        for ( int k = 0; k < N; k++ ) {
            for ( int i = 0; i < N; i++ ) {
                for ( int j = 0; j < N; j++ ) {
                    T[i][j] = min( T[i][j], T[i][k] + T[k][j] );
                }
            }
        }
        int m;
        cin >> m;
        cout << N << endl;
        for ( int i = 0; i < m; i++ ) {
            PVV in = input();
            cout << ( solve( in ) ? "YES" : "NO" ) << endl;
        }
    }
    return 0;
}

Measured memory_bytes: 0