output_description: Print the maximum number of friendly pairs.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      a_1 b_1
      a_2 b_2
      :
      a_N b_N
      c_1 d_1
      c_2 d_2
      :
      c_N d_N
attempt: length = int(input())
  lower = []
  higher = []
  for i in range(length):
      x, y = map(int, input().split(" "))
      lower.append([x, y])
  
  for i in range(length):
      x, y = map(int, input().split(" "))
      higher.append([x, y])
  
  match = [set() for n in range(length)]
  for high in range(length):
      for low in range(length):
          high_x, high_y = higher[high][0], higher[high][1]
          low_x, low_y = lower[low][0], lower[low][1]
          if high_x > low_x and high_y > low_y:
              match[high] |= {low}
  
  matched_lower_set = set()
  matched_higher_set = set()
  
  
  def ret_minimum_match(match, lower_i, matched_higher_set, matched_lower_set):
      min_i = -1
      min_len = 101
      for i, ma in enumerate(match):
          if i in matched_higher_set or lower_i not in ma:
              continue
          if min_len > len(ma - matched_lower_set) > 0:
              min_len = len(ma - matched_lower_set)
              min_i = i
      return {min_i}
  
  
  while True:
  
      lowers = [[] for n in range(length)]
      for i, mat in enumerate(match):
          if i in matched_higher_set:
              continue
          for m in mat:
              if m not in matched_lower_set:
                  lowers[m].append(i)
      only_one_deleted = 0
      # print(lowers, matched_lower_set, matched_higher_set)
      for i, lo in enumerate(lowers):
          if len(lo) == 1:
              matched_higher_set |= ret_minimum_match(
                  match, i, matched_higher_set, matched_lower_set
              )
              matched_lower_set |= {i}
              only_one_deleted = 1
              break
  
      if all([True if len(n) <= 0 else False for n in lowers]):
          break
      if not only_one_deleted:
          min_i, min_len = -1, 101
          for i, lo in enumerate(lowers):
              if min_len > len(lo) > 0:
                  min_i = i
                  min_len = len(lo)
          matched_higher_set |= ret_minimum_match(
              match, min_i, matched_higher_set, matched_lower_set
          )
          matched_lower_set |= {min_i}
  
  print(len(matched_lower_set))
  
problem_description: Statement
  
  On a two-dimensional plane, there are N red points and N blue points. The
  coordinates of the i-th red point are (a_i, b_i), and the coordinates of the
  i-th blue point are (c_i, d_i).
  
  A red point and a blue point can form a _friendly pair_ when, the x-coordinate
  of the red point is smaller than that of the blue point, and the y-coordinate
  of the red point is also smaller than that of the blue point.
  
  At most how many friendly pairs can you form? Note that a point cannot belong
  to multiple pairs.
samples: [{"input": "3\n    2 0\n    3 1\n    1 3\n    4 2\n    0 4\n    5 5", "output": "2\n    \n\nFor example, you can pair (2, 0) and (4, 2), then (3, 1) and (5, 5).\n\n* * *"}, {"input": "3\n    0 0\n    1 1\n    5 2\n    2 3\n    3 4\n    4 5", "output": "2\n    \n\nFor example, you can pair (0, 0) and (2, 3), then (1, 1) and (3, 4).\n\n* * *"}, {"input": "2\n    2 2\n    3 3\n    0 0\n    1 1", "output": "0\n    \n\nIt is possible that no pair can be formed.\n\n* * *"}, {"input": "5\n    0 0\n    7 3\n    2 2\n    4 8\n    1 6\n    8 5\n    6 9\n    5 4\n    9 1\n    3 7", "output": "5\n    \n\n* * *"}, {"input": "5\n    0 0\n    1 1\n    5 5\n    6 6\n    7 7\n    2 2\n    3 3\n    4 4\n    8 8\n    9 9", "output": "4"}]