import Control.Applicative ((<$>))
import Data.ByteString.Char8 (ByteString)
import qualified Data.ByteString.Char8 as B
import Data.List (delete)
import Data.Vector (Vector, (!), (//))
import qualified Data.Vector as V
import Control.Monad.State

main :: IO ()
main = do
  n <- readi B.readInt <$> B.getLine
  replicateM n (B.words <$> B.getLine) >>= solve

solve :: [[ByteString]] -> IO ()
solve bs = evalStateT (sushi bs) (V.replicate 21 [])

sushi :: [[ByteString]] -> StateT (Vector [ByteString]) IO ()
sushi [] = return ()
sushi ((d:rs):bs) | readi B.readInt d == 0 = do
                      let (n:_:as) = rs
                      v <- get
                      put $ v // [(readi B.readInt n, as)]
                      sushi bs
                  | readi B.readInt d == 2 = do
                      v <- get
                      put $ v // [(readi B.readInt (head rs), [])]
                      sushi bs
                  | otherwise = do
                      v <- get
                      case V.findIndex (\ls -> (head rs) `elem` ls) v of
                       Just x -> do
                         lift $ putStrLn (show x)
                         put $ v // [(x, delete (head rs) (v ! x))]
                       Nothing -> lift $ putStrLn "-1"
                      sushi bs

readi :: Integral a =>  (ByteString -> Maybe (a, ByteString)) -> ByteString -> a
readi f s = let Just (n, _) = f s in n