Problem:
Search III

Your task is to write a program of a simple dictionary which implements the following instructions:

insert str: insert a string str in to the dictionary

find str: if the distionary contains str, then print 'yes', otherwise print 'no'

Input

In the first line n, the number of instructions is given. In the following n lines, n instructions are given in the above mentioned format.

Output

Print yes or no for each find instruction in a line.

Constraints

A string consists of 'A', 'C', 'G', or 'T'

1 ≤ length of a string ≤ 12

n ≤ 1000000

Sample Input 1

5
insert A
insert T
insert C
find G
find A

Sample Output 1

no
yes

Sample Input 2

13
insert AAA
insert AAC
insert AGA
insert AGG
insert TTT
find AAA
find CCC
find CCC
insert CCC
find CCC
insert T
find TTT
find T

Sample Output 2

yes
no
no
yes
yes
yes

Notes

Template in C

Solution in Haskell (judge verdict: Memory Limit Exceeded)

import           Control.Applicative
import           Control.Monad

data Dict
    = Empty
    | Node Bool Dict Dict Dict Dict -- End, A, C, G, T
    deriving (Eq, Show)

node :: Dict
node = Node False Empty Empty Empty Empty

dinsert :: String -> Dict -> Dict
dinsert [] (Node _ a c g t) = Node True a c g t
dinsert ('A':xs) (Node e a c g t)
    | a == Empty = Node e (dinsert xs node) c g t
    | otherwise  = Node e (dinsert xs a) c g t
dinsert ('C':xs) (Node e a c g t)
    | c == Empty = Node e a (dinsert xs node) g t
    | otherwise  = Node e a (dinsert xs c) g t
dinsert ('G':xs) (Node e a c g t)
    | g == Empty = Node e a c (dinsert xs node) t
    | otherwise  = Node e a c (dinsert xs g) t
dinsert ('T':xs) (Node e a c g t)
    | t == Empty = Node e a c g (dinsert xs node)
    | otherwise  = Node e a c g (dinsert xs t)

dfind :: String -> Dict -> Bool
dfind [] (Node e _ _ _ _) = e
dfind ('A':xs) (Node _ a _ _ _)
    | a == Empty = False
    | otherwise  = dfind xs a
dfind ('C':xs) (Node _ _ c _ _)
    | c == Empty = False
    | otherwise  = dfind xs c
dfind ('G':xs) (Node _ _ _ g _)
    | g == Empty = False
    | otherwise  = dfind xs g
dfind ('T':xs) (Node _ _ _ _ t)
    | t == Empty = False
    | otherwise  = dfind xs t

solve :: [(Char, String)] -> IO ()
solve xs = go node xs
  where
    go _ [] = return ()
    go d ((a, b):ys)
        | a == 'i' = go (dinsert b d) ys
        | a == 'f' = do
            if dfind b d
                then putStrLn "yes"
                else putStrLn "no"
            go d ys

main :: IO ()
main = do
    n <- readLn :: IO Int
    xs <- fmap ((\[a, b] -> (head a, b)) . words) <$> replicateM n getLine
    solve xs