#include <stdio.h>
#include <cmath>
#include <cstring>
#include <vector>
#include <list>
#include <array>
#include <string>
#include <iostream>
#include <sstream>
#include <algorithm>
#include <unordered_map>
#include <stdexcept>
#include <memory>

using std::string;
using std::vector;
using std::shared_ptr;


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// util
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

std::vector<std::string> split(const std::string& input, char delimiter)
{
    std::istringstream stream(input);

    std::string field;
    std::vector<std::string> result;
    while (std::getline(stream, field, delimiter)) {
        result.push_back(field);
    }
    return result;
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// user func
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

void printList(const vector<int>& list) {
    // print
    for(int i = 0; i < list.size(); i++){
        printf("%d", list[i]);
        if(i != list.size() -1){
            printf(" ");
        }
    }
    printf("\n");
}



//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// logic
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
class Node{

private:
    vector<shared_ptr<Node>> nodes;
public:
    char value;
    Node(const char* word, int index)
        :value(word[index])
    {
        // root
        if (word[index] == '/') return;
        if(word[index] != '\0'){
            this->addChild(word, index + 1);
        }
    }

    void addChild(const char* word, int index){
        for (auto node : this->nodes) {
            if (node->value == word[index]) {
                node->addChild(word, index + 1);
                return;
            }
        }
        // new
        this->nodes.push_back(std::make_shared<Node>(word, index));

        // end
        if (word[index] == '\0' && word[index + 1] == '\0') return;
    }

    bool exists(const char* word, int index) {
        // printf("EXISTS finding: %c ? current-node-val: %c\n", word[index], this->value);

        // when root
        if (this->value == '/') {
            for (auto node : this->nodes) {
                if (node->exists(word, index)) {
                    return true;
                }
            }
            return false;
        }
        // not match
        if (this->value != word[index]) {
            // printf("val: %d != word: %d\n", int(this->value), int(word[index]));
            return false;
        }
        if (this->nodes.empty()) {
            return true;
        } else {
            for (auto node : this->nodes) {
                // printf("node-val:%c\n", node->value);
                if (node->exists(word, index + 1)) {
                    return true;
                }
            }
            return false;
        }
    }
    void print(){
        if(this->value == '\0'){
            printf(" - \\0");
        } else {
            printf(" - %c", this->value);
        }
        if (this->nodes.empty()) {
            printf("\n");
        } else {
            for (auto node: this->nodes) {
                node->print();
            }
        }
    }

};

class Dictionary{
private:
    Node root;
public:
    Dictionary()
        : root(Node("/", 0))
    {
    }

    void insert(char* word) {
        this->root.addChild(word, 0);
    }
    
    bool exists(const char* word) {
        return root.exists(word, 0);
    }

    void print() {
        // this->root.print();
    }
};


void solve() {
   int n;
   scanf("%d", &n);

   Dictionary dictionary;
   
   for (int i = 0; i < n; i++) {
       char instraction[16] = {'\0'};
       char value[16] = {'\0'};
       scanf("%s", instraction);
       scanf("%s", value);

       if (0 == std::strcmp(instraction, "insert")) {
           dictionary.insert(value);
       } else if (0 == std::strcmp(instraction, "find")) {
           if (dictionary.exists(value)){
                printf("yes\n");
           } else {
                printf("no\n");
           }
       }
   }
   dictionary.print();
}


//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// main
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
int main() {
    solve();
    return 0;
}


Measured memory_bytes: 86620