import Control.Applicative
import Control.Monad.State

data SegTree a = Leaf a | Seg Int (SegTree a) a (SegTree a) deriving (Show)
type Query = StateT (SegTree Int) IO ()

main = do
    [n,q] <- map read.words<$>getLine
    let initTree = fromList $ replicate n 0
    evalStateT (rsq q) initTree

rsq :: Int -> Query
rsq 0 = return ()
rsq q = do
    getQuery
    rsq (q-1)

getQuery :: Query
getQuery = do
    [c,x,y] <- liftIO $ map read.words<$>getLine
    case c of
      0 -> add x y
      1 -> getSum x y
      2 -> (get >>= \seg -> lift $ print seg)

add :: Int -> Int -> Query
add i x = modify $ addSeg i x

getSum :: Int -> Int -> Query
getSum s t = get >>= (\seg -> lift . print . getSumSeg (s,t) $ seg)

val :: SegTree a -> a
val (Leaf x) = x
val (Seg _ _ x _) = x

size :: SegTree a -> Int
size (Leaf x) = 1
size (Seg s _ _ _) = s

fromList :: Num a => [a] -> SegTree a
fromList xs = fl n xs
    where n = length xs

fl :: Num a => Int -> [a] -> SegTree a
fl _ [x] = Leaf x
fl n xs = Seg s l v r
    where
        n' = n `div` 2
        (xsL, xsR) = splitAt n' xs
        l = fl n' xsL
        r = fl (n-n') xsR
        v = val l + val r
        s = size l + size r

addSeg :: Num a => Int -> a -> SegTree a -> SegTree a
addSeg _ x (Leaf v) = Leaf (v+x)
addSeg i x (Seg n l v r)
  | i <= n' = Seg n left (val left + val r) r
  | otherwise = Seg n l (val l + val right) right
  where
      n' = n `div` 2
      left = addSeg i x l
      right = addSeg (i - n') x r

getSumSeg :: Num a => (Int, Int) -> SegTree a -> a
getSumSeg _ (Leaf x) = x
getSumSeg (s,t) (Seg n l v r)
  | s == 1 && t == n = v
  | t <= n' = getSumSeg (s,t) l
  | s > n' = getSumSeg (s - n', t - n') r
  | s <= n' && t > n' = lsum + rsum
  where n' = n `div` 2
        lsum = getSumSeg (s,n') l
        rsum = getSumSeg (1,t - n') r
