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: # coding:utf-8
  
  import sys
  
  # from collections import Counter, defaultdict
  
  INF = float("inf")
  MOD = 10**9 + 7
  
  
  def LI():
      return [int(x) for x in sys.stdin.readline().split()]
  
  
  def LI_():
      return [int(x) - 1 for x in sys.stdin.readline().split()]
  
  
  def LS():
      return sys.stdin.readline().split()
  
  
  def II():
      return int(sys.stdin.readline())
  
  
  def SI():
      return input()
  
  
  def main():
      n = II()
      red = [[a + b, a, b] for a, b in (LI() for _ in range(n))]
      blue = [[a + b, a, b] for a, b in (LI() for _ in range(n))]
  
      ans = 0
      for _ in range(n):
          red = red[-1:] + red[:-1]
          used = [0] * n
          res = 0
          for s, a, b in red:
              near = -1
              d = INF
              for i, (ss, x, y) in enumerate(blue):
                  if a < x and b < y:
                      tmp = x - a + y - b
                      if tmp < d and not used[i]:
                          near = i
                          d = tmp
  
              if near != -1:
                  used[near] = 1
                  res += 1
          ans = max(ans, res)
  
      red.reverse()
      for _ in range(n):
          red = red[-1:] + red[:-1]
          used = [0] * n
          res = 0
          for s, a, b in red:
              near = -1
              d = INF
              for i, (ss, x, y) in enumerate(blue):
                  if a < x and b < y:
                      tmp = x - a + y - b
                      if tmp < d and not used[i]:
                          near = i
                          d = tmp
  
              if near != -1:
                  used[near] = 1
                  res += 1
          ans = max(ans, res)
  
      red.reverse()
      red.sort()
      for _ in range(n):
          red = red[-1:] + red[:-1]
          used = [0] * n
          res = 0
          for s, a, b in red:
              near = -1
              d = INF
              for i, (ss, x, y) in enumerate(blue):
                  if a < x and b < y:
                      tmp = x - a + y - b
                      if tmp < d and not used[i]:
                          near = i
                          d = tmp
  
              if near != -1:
                  used[near] = 1
                  res += 1
          ans = max(ans, res)
  
      red.reverse()
      for _ in range(n):
          red = red[-1:] + red[:-1]
          used = [0] * n
          res = 0
          for s, a, b in red:
              near = -1
              d = INF
              for i, (ss, x, y) in enumerate(blue):
                  if a < x and b < y:
                      tmp = x - a + y - b
                      if tmp < d and not used[i]:
                          near = i
                          d = tmp
  
              if near != -1:
                  used[near] = 1
                  res += 1
          ans = max(ans, res)
  
      return ans
  
  
  print(main())
  
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"}]