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: class Node:
      def __init__(self, idx=None):
          self.idx = idx
          self.edge = []
          self.level = None
          self.par = None
  
  
  class Edge:
      def __init__(self, to, cap, rev=None):
          self.to = to
          self.cap = cap
          self.rev = rev
  
  
  from collections import deque
  
  
  class BipartiteMatching:
      def __init__(self, n, m):
          self.n = n
          self.m = m
          self.inf = 10**18
          self.source = Node()
          self.sink = Node()
          self.lt = [Node(i) for i in range(n)]
          self.rt = [Node(i) for i in range(m)]
          for i in range(n):
              edge = Edge(self.lt[i], 1)
              rev = Edge(self.source, 0)
              edge.rev, rev.rev = rev, edge
              self.source.edge.append(edge)
              self.lt[i].edge.append(rev)
          for i in range(m):
              edge = Edge(self.sink, 1)
              rev = Edge(self.rt[i], 0)
              edge.rev, rev.rev = rev, edge
              self.rt[i].edge.append(edge)
              self.sink.edge.append(rev)
  
      def add(self, x, y):
          lt = self.lt[x]
          rt = self.rt[y]
          edge = Edge(rt, 1)
          rev = Edge(lt, 0)
          edge.rev, rev.rev = rev, edge
          lt.edge.append(edge)
          rt.edge.append(rev)
  
      def maximum_matching(self):
          flow = 0
          while True:
              queue = deque([self.source])
              self.source.level = 0
              self.sink.level = None
              for i in range(self.n):
                  self.lt[i].level = None
              for i in range(self.m):
                  self.rt[i].level = None
              while queue:
                  node = queue.popleft()
                  for edge in node.edge:
                      to = edge.to
                      if edge.cap and to.level is None:
                          to.level = node.level + 1
                          queue.append(to)
              if self.sink.level is None:
                  break
              stack = [self.source]
              self.source.par = None
              self.sink.par = None
              for i in range(self.n):
                  self.lt[i].par = None
              for i in range(self.m):
                  self.rt[i].par = None
              while stack:
                  node = stack.pop()
                  if node is self.sink:
                      break
                  for edge in node.edge:
                      to = edge.to
                      if edge.cap and node.level < to.level:
                          to.par = edge.rev
                          stack.append(to)
              node = self.sink
              while node is not self.source:
                  node.par.cap = 1
                  node.par.rev.cap = 0
                  node = node.par.to
              flow += 1
          return flow
  
  
  N = int(input())
  R = [tuple(map(int, input().split())) for _ in range(N)]
  B = [tuple(map(int, input().split())) for _ in range(N)]
  
  bip = BipartiteMatching(N, N)
  
  for i in range(N):
      a, b = R[i]
      for j in range(N):
          c, d = B[j]
          if a < c and b < d:
              bip.add(i, j)
  
  print(bip.maximum_matching())
  
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"}]