output_description: When the minimum required number of recorders is x, print the value of x.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N C
      s_1 t_1 c_1
      :
      s_N t_N c_N
attempt: import sys
  from io import StringIO
  import unittest
  from itertools import accumulate
  
  
  def resolve():
      end = 100000
      input = sys.stdin.readline
      N, C = map(int, input().rstrip().split())
      S = [list(map(int, input().rstrip().split())) for _ in range(N)]
  
      l = [[0 for _ in range(C)] for __ in range(2 * end)]
      for i in range(N):
          l[S[i][0] * 2 - 1][S[i][2] - 1] += 1
          if S[i][1] != end:
              l[S[i][1] * 2 + 1][S[i][2] - 1] -= 1
      """
      ans=0
      npl=np.array(l)
      for i in range(C):
          snpl=npl[:,i]
          buf=list(snpl)
          asum = list(accumulate(buf))
          M=max(asum)
          ans=max(ans,M)
      """
      asum = [0 for __ in range(2 * end)]
      for i in range(2 * end):  # 列(C)で和を取る
          for j in range(C):
              asum[i] += l[i][j]
      asum2 = list(accumulate(asum))
      ans = max(asum2)
      ans = min(ans, C)
  
      print(int(ans))
  
  
  class TestClass(unittest.TestCase):
      def assertIO(self, input, output):
          stdout, stdin = sys.stdout, sys.stdin
          sys.stdout, sys.stdin = StringIO(), StringIO(input)
          resolve()
          sys.stdout.seek(0)
          out = sys.stdout.read()[:-1]
          sys.stdout, sys.stdin = stdout, stdin
          self.assertEqual(out, output)
  
      def test_入力例_1(self):
          input = """3 2
  1 7 2
  7 8 1
  8 12 1"""
          output = """2"""
          self.assertIO(input, output)
  
      def test_入力例_2(self):
          input = """3 4
  1 3 2
  3 4 4
  1 4 3"""
          output = """3"""
          self.assertIO(input, output)
  
      def test_入力例_3(self):
          input = """9 4
  56 60 4
  33 37 2
  89 90 3
  32 43 1
  67 68 3
  49 51 3
  31 32 3
  70 71 1
  11 12 3"""
          output = """2"""
          self.assertIO(input, output)
  
  
  if __name__ == "__main__":
      # unittest.main()
      resolve()
  
problem_description: Statement
  
  Joisino is planning to record N TV programs with recorders.
  
  The TV can receive C channels numbered 1 through C.
  
  The i-th program that she wants to record will be broadcast from time s_i to
  time t_i (including time s_i but not t_i) on Channel c_i.
  
  Here, there will never be more than one program that are broadcast on the same
  channel at the same time.
  
  When the recorder is recording a channel from time S to time T (including time
  S but not T), it cannot record other channels from time S-0.5 to time T
  (including time S-0.5 but not T).
  
  Find the minimum number of recorders required to record the channels so that
  all the N programs are completely recorded.
samples: [{"input": "3 2\n    1 7 2\n    7 8 1\n    8 12 1", "output": "2\n    \n\nTwo recorders can record all the programs, for example, as follows:\n\n  * With the first recorder, record Channel 2 from time 1 to time 7. The first program will be recorded. Note that this recorder will be unable to record other channels from time 0.5 to time 7.\n  * With the second recorder, record Channel 1 from time 7 to time 12. The second and third programs will be recorded. Note that this recorder will be unable to record other channels from time 6.5 to time 12.\n\n* * *"}, {"input": "3 4\n    1 3 2\n    3 4 4\n    1 4 3", "output": "3\n    \n\nThere may be a channel where there is no program to record.\n\n* * *"}, {"input": "9 4\n    56 60 4\n    33 37 2\n    89 90 3\n    32 43 1\n    67 68 3\n    49 51 3\n    31 32 3\n    70 71 1\n    11 12 3", "output": "2"}]