output_description: For each case, you have to output the maximum duration (in minutes) for which
  he can watch television without seeing any commercial.
input_description: The input will consist of several cases. In each case, the first line of the
  input will be n, the number of channels, which will then be followed by p and
  q, the time interval between which he will be watching the TV. It will be
  followed by 2n lines, giving the time slots for each of the channels. For each
  channel, the first line will be k, the number of commercial slots, and it will
  then be followed by 2k numbers giving the commercial slots in order.
  
  The input will be terminated by values 0 for each of n, p, q. This case should
  not be processed.
attempt: conv = lambda t: (t // 100) * 60 + (t % 100)
  while 1:
      N, P, Q = map(int, input().split())
      if N == P == Q == 0:
          break
      P = conv(P)
      Q = conv(Q)
      CM = [0] * (Q - P + 1)
      for i in range(N):
          k = int(input())
          (*T,) = map(int, input().split())
          for s, t in zip(T[::2], T[1::2]):
              s = conv(s)
              t = conv(t)
              CM[s - P] += 1
              CM[t - P] -= 1
      cnt = ans = 0
      for i in range(Q - P):
          CM[i + 1] += CM[i]
          if CM[i] < N:
              cnt += 1
          else:
              cnt = 0
          ans = max(ans, cnt)
      print(ans)
  
problem_description: Boring Commercial
  
  Now it is spring holidays. A lazy student has finally passed all final
  examination, and he decided to just kick back and just watch TV all day. Oh,
  his only source of entertainment is watching TV. And TV commercial, as usual,
  are a big nuisance for him. He can watch any thing on television, but cannot
  bear even a single second of commercial. So to prevent himself from the
  boredom of seeing the boring commercial, he keeps shuffling through the TV
  channels, so that he can watch programs on different channels without seeing
  even a single commercial.
  
  Given the number of channels, and the duration at which the TV commercials are
  showed on each of the channels, you have to write a program which will print
  the longest interval for which the lazy student can watch the television by
  shuffling between the different channels without ever seeing an TV commercial.
  
  For example, consider the simplified situation where there are only three
  television channels, and suppose that he is watching TV from 2100 hrs to 2400
  hrs. Suppose that the commercials are displayed at following time on each of
  the channels.
  
    * Channel 1: 2100 to 2130, 2200 to 2230 and 2300 to 2330
    * Channel 2: 2130 to 2200, 2330 to 2400
    * Channel 3: 2100 to 2130, 2330 to 2400
  
  Then in this case, he can watch TV without getting interrupted by commercials
  for full 3 hours by watching Channel 2 from 2100 to 2130, then Channel 3 from
  2130 to 2330, and then Channel 1 from 2330 to 2400.
samples: [{"input": "2100 2400\n    1\n    2130 2200\n    3 2100 2400\n    3\n    2100 2130 2200 2230 2300 2330\n    2\n    2130 2200 2330 2400\n    2\n    2100 2130 2330 2400\n    0 0 0", "output": "180"}]