{-# LANGUAGE BangPatterns #-}

import qualified Data.Map as M
import Data.List
import Data.Maybe
import qualified Data.ByteString.Lazy.Char8 as B

data RecItem = RecItem {
    riStart :: Int
  , riEnd :: Int
  , riChannel :: Int
  } deriving (Show)

genRecItem !s !e !c = RecItem s e c

data EventType = ETStart | ETEnd
                           deriving (Eq, Ord)

data Event = Event {
    evTime :: Int
  , evType :: EventType
} deriving (Eq, Ord)

calc :: M.Map Int [RecItem] -> Int -> Int
calc ris numC =
  countPara $ sort $ concat [eventList ris c | c <- [1 .. numC]]

eventList :: M.Map Int [RecItem] -> Int -> [Event]
eventList ris c = 
  concat [[Event s ETStart, Event e ETEnd] |
          RecItem s e _ <- paste $ sortOn riStart $ ris M.! c]
  where 
    ffilt (RecItem s e c') = c == c'
    paste = paste2 []
    paste2 acc [] = reverse acc
    paste2 [] (ri : ris) = paste2 [ri] ris
    paste2 acc@((RecItem sA eA c) : risA) (riB@(RecItem sB eB _) : ris)
      | eA == sB  = paste2 ((RecItem sA eB c) : risA) ris
      | otherwise = paste2 (riB : acc) ris


--    paste = foldr gen []
--    gen ri [] = [ri]
--    gen ri1@(RecItem s1 e1 _) ris2@((RecItem s2 e2 c) : ris)
--      | e1 == s2  = RecItem s1 e2 c : ris
--      | otherwise = ri1 : ris2

countPara :: [Event] -> Int
countPara evs = f 0 0 evs
  where f cur vMax [] = vMax
        f cur vMax ((Event t ETStart) : evs) = f (cur + 1) vMax' evs
          where vMax' = if cur == vMax then vMax + 1 else vMax
        f cur vMax ((Event t ETEnd)   : evs) = f (cur - 1) vMax evs

{-
main :: IO ()
main = do
  x <- getLine
  let [numRI, numC] = [read w | w <- words x]
  ris <- readData numRI numC
  putStrLn $ show $ calc ris numC

readData :: Int -> Int -> IO (M.Map Int [RecItem])
readData numRI numC = do
  f numRI (M.fromList [(c, []) | c <- [1 .. numC]])
  where
    f :: Int -> M.Map Int [RecItem] -> IO (M.Map Int [RecItem])
    f n acc | n == 0    = return acc
            | otherwise = do
                x <- getLine
                let [s, e, c] = [read w | w <- words x]
                f (n - 1) (M.adjust ((genRecItem s e c) :) c acc)
-}

myReadInt :: B.ByteString -> Int
myReadInt = fst . fromJust . B.readInt

main :: IO ()
main = do
  all <- B.getContents
  let (head:rest) = B.lines all
  let [numRI, numC] = [myReadInt w | w <- B.words head]
  let ris = foldr bin (M.fromList [(c,[]) | c <- [1 .. numC]]) rest
        where bin line m = M.adjust ((genRecItem s e c) :) c m
                where [s, e, c] = [myReadInt w | w <- B.words line]
  putStrLn $ show $ calc ris numC

