#include <stdio.h>
#include <malloc.h>
#include <stdlib.h>
#include <string.h>
#define MAX 1000
#define     MEMCHECK(x) if(x==NULL) { printf("Nema memorija!\n"); exit(-1); }

typedef char * key_struct;
typedef char * value_struct;

typedef struct hashmap_element
{
    key_struct key;
    value_struct value; } hashmap_node;

typedef struct element
{
    hashmap_node info;
    struct element *link;
} h_node;
typedef h_node * h_nodep;

typedef struct cbht
{
    int size;
    h_node ** buckets;
} hashmap;

void make_hash_map(hashmap *tptr, int n)
{
    int i;
    tptr->size=n;
    tptr->buckets=(h_node **) calloc(tptr->size, sizeof(h_node *));


    for(i=0;i<tptr->size;i++)
     tptr->buckets[i]=NULL;
}

int hashCode(key_struct key)
{
    return key[0]-'a';
}

int hash(key_struct key, hashmap *tptr)
{
        return hashCode(key)%(tptr->size);

}

h_node * search(key_struct targetKey, hashmap *tptr)
{
    int h;
    h_node *p;
    h=hash(targetKey, tptr);
    for(p=tptr->buckets[h]; p!=NULL; p=p->link)
    {
        if (!strcmp((p->info).key, targetKey))
            return p;
    }
    return NULL;
}



void insert(key_struct key, value_struct val, hashmap *tptr)
{
    h_node *tmp;
    h_node *p;
    int h;

    h=hash(key, tptr);
    p=(h_node *) malloc(sizeof(h_node)); (p->info).value=val;
    (p->info).key=key;

    for(tmp=tptr->buckets[h]; tmp!=NULL; tmp=tmp->link)
    {
if (!strcmp((tmp->info).key, key))
        {
            (tmp->info).value=val; return;
        }
    }

p->link=tptr->buckets[h];
    tptr->buckets[h]=p;
}

void delete(key_struct key, hashmap *tptr)
{
    h_node *p, *last;
    int h;

    h=hash(key,tptr);
    for (p=tptr->buckets[h]; p!=NULL; p=p->link)
    {
        if (!strcmp((p->info).key, key))
            break;
    }
    if (p==NULL) return;

    if(p==tptr->buckets[h])
        tptr->buckets[h]=p->link;
    else
    {
for (last=tptr->buckets[h]; (last!=NULL)&&(last->link!=NULL); last=last->link)
        {
            if (last->link==p)
                break;
        }
        last->link=p->link;
    }

    free(p); }

void print_h_node(h_node *p)
{
    printf("(%s,%s)",(p->info).key,(p->info).value);
}

void print_hashmap(hashmap *tptr)
{
    int i;
    h_node *p;

    for(i=0; i<tptr->size; i++)
    {
        printf("%d:",i);
        for(p=tptr->buckets[i]; p!=NULL; p=p->link)
            print_h_node(p);
        printf("\n");
    }
}

int main()
{
    hashmap *hashTabela=(hashmap *)malloc(sizeof(hashmap));
    int N,i;
    scanf("%d",&N);

    make_hash_map(hashTabela,2*N+1);

    char user[100][30];
    char pass[100][30];
    int h;

    for(i=0; i<N; i++)
    {
        scanf("%s",user[i]);
        scanf("%s",pass[i]);
        insert(user[i],pass[i],hashTabela);
    }

    char chusername[100][100];
    char chlozinka[100][100];
    i=0;
    while(scanf("%s", chusername[i])){
        if(!strcmp("KRAJ",chusername[i]))
            break;
        scanf("%s", chlozinka[i]);
        i++;
    }



    int j;
    for(j=0; j<i; j++)
    {
        int flg = 0;
        h_node * tmp = search(chusername[j], hashTabela);
       if (tmp == NULL)
        {
            printf("Nenajaven\n");
        }
        else
        {
            if (!strcmp(tmp->info.value,chlozinka[j]))
            {
                printf("Najaven\n");
                flg = 1;
            }
            else printf("Nenajaven\n");
        }
        if (flg) break;
    }

    return 0;
}