#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <math.h>

//============================================================================
#define pred(x) ((x)-1)
#define succ(x) ((x)+1)
//============================================================================
struct List{
    struct List *prev;
    struct List *next;
    char   *cptr;
    long   key;
};
typedef struct List TList;
//----------------------------------------------------------------------------
typedef struct{
    TList *top,*btm;
    long item;
}TSearch;
//============================================================================
#define MAXCMD 4
const char Command[MAXCMD][20]={
    "insert",
    "delete",
    "deleteFirst",
    "deleteLast"
};
TList *Ltop,*Lbtm;

//============================================================================
void dump(int *A, int N)
{
    int i;

    for (i=0; i<N; i++){
        if (i)
            printf(" ");
        printf("%d", A[i]);
    }
    printf("\n");
}
//============================================================================
void cdump(char *str)
{
    int i;

    printf("%d:", strlen(str));;
    for (i=0; i<strlen(str); i++){
        if (i)
            printf(" ");
        printf("%02X", (unsigned char)str[i]);
    }
    printf("\n");
}
//============================================================================
TList *forwardlist(TList *lst, long val)
{
    long i;

    for (i=0; i<abs(val) && lst!=NULL; i++, lst=lst->next);
    return lst;
}
//============================================================================
TList *backwardlist(TList *lst, long val)
{
    long i;

    for (i=0; i<abs(val) && lst!=NULL; i++, lst=lst->prev);
    return lst;
}
//============================================================================
TList *searchlist(TSearch *src, char *str)
{
    TList *lst,*top,*btm;   long item,res;

    lst = forwardlist(top, src->item/2);
    for (top=src->top, btm=src->btm, item=src->item/4, res=1; lst!=NULL; item/=2){
        res=strcmp(lst->cptr, str);
        if (!res)
            return lst;
        if (res<0){
            top = lst;
            lst = forwardlist(lst, item);
        }else{
            btm = lst;
            lst = backwardlist(lst, item);
        }
    }
    return NULL;
}
//============================================================================
void insertlist(TList *lst, TList *ins)
{
    ins->prev=lst->prev;
    ins->next=lst;
    lst->prev=ins;
    if (ins->prev!=NULL){
        ins->prev->next=ins;
    }
}
//============================================================================
void addlist(char *str)
{
    TList *lst;

    lst=malloc(sizeof(TList));
    //memset(lst, 0, sizeof(TList));
    if (Ltop==NULL){
        Ltop=lst;
        Lbtm=lst;
        Ltop->prev=NULL;
        Ltop->next=NULL;
    }else{
       lst->next=Lbtm->next;
       lst->prev=Lbtm;
       Lbtm->next=lst;
       Lbtm=lst;
    }
    lst->cptr=malloc(succ(strlen(str)));
    strcpy(lst->cptr, str);
}
//============================================================================
void deletelist(TList *lst)
{
    if (lst==NULL)
        return;
    if (lst==Ltop)
        Ltop=Ltop->next;
    if (lst==Lbtm)
        Lbtm=Lbtm->prev;
    if (lst->prev!=NULL)
        lst->prev->next=lst->next;
    if (lst->next!=NULL)
        lst->next->prev=lst->prev;
    if (lst->cptr)
        free(lst->cptr);
    free(lst);
}
//============================================================================
void cleanlist(TSearch *src)
{
    if (src->top==NULL)
        return;
    while (src->top->next!=NULL){
        deletelist(src->top->next);
    }
    deletelist(src->top);
}
//============================================================================
void initsearch(TSearch *src)
{
    src->top=src->btm=NULL;
    src->item=0;
}
//============================================================================
void addsearch(TSearch *src, char *str)
{
    TList *lst,*top;

    lst=malloc(sizeof(TList));
    //memset(lst, 0, sizeof(TList));
    lst->cptr=malloc(succ(strlen(str)));
    src->item++;
    strcpy(lst->cptr, str);
    if (src->top==NULL){
        src->top=lst;
        src->btm=lst;
        src->top->prev=NULL;
        src->top->next=NULL;
    }else{
       for (top=src->top; top!=NULL; top=top->next)
            if (0<strcmp(top->cptr, lst->cptr)){
                insertlist(top, lst);
                break;
            }
        if (top==NULL){
            lst->next=src->btm->next;
            src->btm->next=lst;
            lst->prev=src->btm;
            src->btm=lst;
        }
       /*lst->next=src->btm->next;
       lst->prev=src->btm;
       src->btm->next=lst;
       src->btm=lst;*/
    }
}
//============================================================================
TList *wordsearch(TSearch *src, char *str)
{
    TList *lst;

    lst=src->top;
    while(lst!=NULL){
        if (!strcmp(lst->cptr, str))
            return lst;
        lst=lst->next;
    }
    return NULL;
}
//============================================================================

void input(void)
{
    long n,i; char command[10], string[20]; TSearch Asrc,Csrc,Gsrc,Tsrc,*Psrc;

    initsearch(&Asrc);
    initsearch(&Csrc);
    initsearch(&Gsrc);
    initsearch(&Tsrc);
    scanf("%ld", &n);
    for (i=0; i<n; i++){
        scanf("%s %s", command, string);
        switch(*string){
            //case 'A': Psrc=&Asrc; break;
            case 'C': Psrc=&Csrc; break;
            case 'G': Psrc=&Gsrc; break;
            case 'T': Psrc=&Tsrc; break;
            default: Psrc=&Asrc;  break;
        }
        if (*command=='i')
            addsearch(Psrc, string);
        else
        if  (*command=='f')
            printf("%s\n", (wordsearch(Psrc, string)!=NULL)?"yes":"no");
    }
    cleanlist(&Asrc);
    cleanlist(&Csrc);
    cleanlist(&Gsrc);
    cleanlist(&Tsrc);
}
//============================================================================
int main()
{
    input();
    return 0;
}
//---------------------------------------------------------------------------