import Control.Monad
import Data.Maybe
import qualified Data.ByteString.Char8 as BS

tuplify2 (x:y:_) = (x,y)
tuplify2 _ = undefined

--Input functions with ByteString
readInt = fromInteger . fst . fromJust . BS.readInteger
readIntTuple = tuplify2 . map readInt . BS.words
readIntList = map readInt . BS.words

getInt = readInt <$> BS.getLine
getIntList = readIntList <$> BS.getLine
getIntNList n = map readIntList <$> replicateM (fromIntegral n) BS.getLine
getIntMatrix = map readIntList . BS.lines <$> BS.getContents
getIntTuple = readIntTuple <$> BS.getLine
getIntNTuples n = map readIntTuple <$> replicateM (fromIntegral n) BS.getLine
getIntTuples = map readIntTuple . BS.lines <$> BS.getContents



data SegmentTree = Node Int Int SegmentTree SegmentTree | Leaf Int
    deriving Show

newTree :: [Int] -> SegmentTree
newTree lis
    | n == 1 = Leaf $ head lis
    | otherwise = Node value n left right
    where n = length lis
          half = n `div` 2
          left = newTree $ take half lis
          right = newTree $ drop half lis
          value = min (val left) (val right)

query :: Int -> Int -> SegmentTree -> (Int, Int)
query _ _ (Leaf v) = (0, v)
query from to (Node v n left right)
    | to < half      = qLeft
    | half <= from    = qRight
    | from < half && half <= to =  minTuple qLeft qRight
    where half = n `div` 2
          qLeft = query from to left
          qRight = ((fst qRightRaw) + half, snd qRightRaw)
          qRightRaw = query (from - half) (to - half) right
          minTuple t1 t2 = if (snd t1) < (snd t2) then t1 else t2

update :: Int -> Int -> SegmentTree -> SegmentTree
update _ newval (Leaf v) = Leaf newval
update index newval (Node v n left right)
    | index < half = Node (min (val newLeft) (val right)) n newLeft right
    | otherwise = Node (min (val left) (val newRight)) n left newRight
    where half = n `div` 2
          newLeft = update index newval left
          newRight = update (index - half) newval right

val :: SegmentTree -> Int
val (Node value _ _ _) = value
val (Leaf value) = value

main = do

    [n, q] <- getIntList

    a <- getIntList

    ops <- replicateM q $ getIntList

    let tree = newTree a

    operate tree ops

operate :: SegmentTree -> [[Int]] -> IO ()
operate tree [] = return ()
operate tree (op:ops) = do
    let [operation, ap, bp] = op
    let a = ap - 1
    let b = bp - 1

    case operation of
        1 -> do
            let (aind, aval) = query a a tree
            let (bind, bval) = query b b tree
            let newTree1 = update aind bval tree
            let newTree2 = update bind aval newTree1
            operate newTree2 ops
        2 -> do
            print $ (+1) $ fst (query a b tree)
            operate tree ops