import Data.Monoid
import Control.Monad.State

data Seg a = Nil | Seg Int a (Seg a) (Seg a) deriving (Show, Eq)

initSeg :: (Monoid m) => Int -> Seg m
initSeg 0 = Nil
initSeg n = Seg n mempty (initSeg (n-1)) (initSeg (n-1))

updateSeg :: (Monoid m) => Int -> m -> Seg m -> Seg m
updateSeg 0 a (Seg 1 _ _ _) = Seg 1 a Nil Nil
updateSeg _ _ s@(Seg 1 _ _ _) = s
updateSeg k a (Seg n b l@(Seg _ al _ _) r@(Seg _ ar _ _))
  | k < c = Seg n (mappend al' ar) l' r
  | otherwise = Seg n (mappend al ar') l r'
  where 
    c = 2^(n-2)
    l'@(Seg _ al' _ _) = updateSeg k a l
    r'@(Seg _ ar' _ _) = updateSeg (k-c) a r

querySeg :: (Monoid m) => Int -> Int -> Seg m -> m
querySeg 0 1 (Seg 1 a _ _) = a
querySeg _ _ (Seg 1 _ _ _) = mempty
querySeg i j s@(Seg n a l r)
  | i == 0 && j == 2*c = a
  | j < c = querySeg i j l
  | c <= i = querySeg (i-c) (j-c) r
  | otherwise = mappend (querySeg i c l) (querySeg 0 (j-c) r)
  where
    c = 2^(n-2)

newtype Min = Min Int deriving Show
instance Monoid Min where
  mempty = Min (2^31 - 1)
  mappend (Min a) (Min b) = Min (min a b)

fromMin (Min a) = a

getNums :: IO [Int]
getNums = liftM (map read . words) getLine

main = do
  n:q:_ <- getNums
  let depth = 1 + ((ceiling $ logBase 2 (fromIntegral n))) in
    evalStateT (replicateM_ q proc) $ initSeg depth

proc :: StateT (Seg Min) IO ()
proc = do
  com:x:y:_ <- lift $ getNums
  case com of
    0 -> modify $ updateSeg x (Min y)
    1 -> do
      s <- get
      lift $ print $ fromMin $ querySeg x (y+1) s