Mahmoud wants to write a new dictionary that contains n words and relations between them. There are two types of relations: synonymy (i. e. the two words mean the same) and antonymy (i. e. the two words mean the opposite). From time to time he discovers a new relation between two words.

He know that if two words have a relation between them, then each of them has relations with the words that has relations with the other. For example, if like means love and love is the opposite of hate, then like is also the opposite of hate. One more example: if love is the opposite of hate and hate is the opposite of like, then love means like, and so on.

Sometimes Mahmoud discovers a wrong relation. A wrong relation is a relation that makes two words equal and opposite at the same time. For example if he knows that love means like and like is the opposite of hate, and then he figures out that hate means like, the last relation is absolutely wrong because it makes hate and like opposite and have the same meaning at the same time.

After Mahmoud figured out many relations, he was worried that some of them were wrong so that they will make other relations also wrong, so he decided to tell every relation he figured out to his coder friend Ehab and for every relation he wanted to know is it correct or wrong, basing on the previously discovered relations. If it is wrong he ignores it, and doesn't check with following relations.

After adding all relations, Mahmoud asked Ehab about relations between some words based on the information he had given to him. Ehab is busy making a Codeforces round so he asked you for help.

Input

The first line of input contains three integers n, m and q (2 ≤ n ≤ 105, 1 ≤ m, q ≤ 105) where n is the number of words in the dictionary, m is the number of relations Mahmoud figured out and q is the number of questions Mahmoud asked after telling all relations.

The second line contains n distinct words a1, a2, ..., an consisting of small English letters with length not exceeding 20, which are the words in the dictionary.

Then m lines follow, each of them contains an integer t (1 ≤ t ≤ 2) followed by two different words xi and yi which has appeared in the dictionary words. If t = 1, that means xi has a synonymy relation with yi, otherwise xi has an antonymy relation with yi.

Then q lines follow, each of them contains two different words which has appeared in the dictionary. That are the pairs of words Mahmoud wants to know the relation between basing on the relations he had discovered.

All words in input contain only lowercase English letters and their lengths don't exceed 20 characters. In all relations and in all questions the two words are different.

Output

First, print m lines, one per each relation. If some relation is wrong (makes two words opposite and have the same meaning at the same time) you should print "NO" (without quotes) and ignore it, otherwise print "YES" (without quotes).

After that print q lines, one per each question. If the two words have the same meaning, output 1. If they are opposites, output 2. If there is no relation between them, output 3.

See the samples for better understanding.

3 3 4
hate love like
1 love like
2 love hate
1 hate like
love like
love hate
like hate
hate like
YES
YES
NO
1
2
2
2
8 6 5
hi welcome hello ihateyou goaway dog cat rat
1 hi welcome
1 ihateyou goaway
2 hello ihateyou
2 hi goaway
2 hi hello
1 hi hello
dog cat
dog hi
hi hello
ihateyou goaway
welcome ihateyou
YES
YES
YES
YES
NO
YES
3
3
1
1
2
題目大意：給出n個詞，m個單詞之間的關係（關係包括近義詞和反義詞），你需要根據已有的單詞之間的關係判斷所給的這m行關係正確與否（正確輸出YES反之輸出NO），接下來讓你輸出接下來q行，詢問的單詞之間的關係（同義詞、反義詞、沒關係）。

分析：首先，能夠很容易想到本題考查的是並查集，那麼接下來我們要考慮本題怎麼建立並查集。本題與普通的並查集不同的地方在於 節點與節點之間存在存在確定的關係，因此我們在建立常規並查集的同時（這裡建樹比較隨意，讓給定的關係中一個為父親節點一個是兒子節點即可），需要建立節點之間關係的並查集。這個關係怎麼確立呢，我們需要找到所有子節點與祖先的關係，這個關係怎麼找呢。這裡，我們把近義詞設為0，反義詞設為1，（這個把關係之間設成0、1 其實是種類並查集的套路，如果不瞭解的：傳送門）我們知道的是相鄰的兩節點的關係（比如 父親節點和子節點，爺爺節點和父親節點），那麼我們如何得到兒子節點和爺爺節點的關係呢，列舉一下會發現，與爺爺節點的關係=（父親節點+兒子節點）%2。 這樣我們就找到在同一個樹內，各節點的關係。下面還有一個問題，當兩個節點本屬於兩個樹，現在要建立關係，也就是要建立那個樹之間祖先的關係那麼怎麼找到這個關係呢，下面我們設兩節點為x、y,其祖先節點為fx、fy,現在我們知道的關係是x~y,x~fx,y~fy,要求的關係是fy~fx.那麼fy~fx=(fy~y)+(y~x)+(x~fx)。   下面上程式碼：

#include <iostream>
#include <cstring>
#include <map>
using namespace std;
int f[100010] , root[100010] , n , m;
void init()
{
    for(int i = 1 ; i <= n ; i++)
    {
        f[i] = i ;
        root[i] = 0;
    }
}
int find(int x)//找到各點的跟節點，並把各壓縮到跟節點上
{
    if(x == f[x])
        return x;
    int tmp = find(f[x]);
    root[x] = (root[x] + root[f[x]]) % 2;//建立各點與跟節點的關係
    return f[x] = tmp;
}
string s , s1 , s2;
map<string , int>mp;
int main()
{
    int x , y , num , q;
    cin >> n >> m >> q;
    init();
    for(int i = 0 ; i < n ; i++)
    {
        cin >> s;
        mp[s] = i + 1;
    }
    for(int i = 1 ; i <= m ; i++)
    {
        cin >> num >> s1 >> s2;
        x = mp[s1] ; y = mp[s2];
        int t1 = find(x) , t2 = find(y);
        if(num == 1)
        {
            if(t1 == t2)
            {
                if(root[x] != root[y])//若兩個的關係不相等，則證明為反義詞，則所給題設為假
                {
                    cout << "NO" << endl;
                }
                else
                {
                    cout << "YES" << endl;
                }
            }
            else
            {
                cout << "YES" << endl;
                f[t1] = t2;
                root[t1] = (root[y] + root[x]+0) % 2;//建立兩個樹的祖先節點之間的關係
            }
        }
        else
        {
            if(t1 == t2)
            {
                if(root[x] == root[y])//若兩個的關係相等，則證明為近義詞，則所給題設為假

                {
                    cout << "NO" << endl;
                }
                else
                {
                    cout << "YES" << endl;
                }
            }
            else
            {
                cout << "YES" << endl;
                f[t1] = t2;
                root[t1] = (root[y] + root[x] + 1) % 2;//建立兩個樹的祖先節點之間的關係
            }
        }
    }
    while(q--)
    {
        cin >> s1 >> s2;
        x = mp[s1] ; y = mp[s2];
        int t1 = find(x) , t2 = find(y);
        if(t1 == t2)
        {
            if(root[x] == root[y])
            {
                cout << 1 << endl;
            }
            else
            {
                cout << 2 << endl;
            }
        }
        else
        {
            cout << 3 << endl;
        }
    }
    return 0;
}