output_description: Print the answer.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      x_1 y_1
      x_2 y_2
      :
      x_N y_N
attempt: n = int(input())
  # n = 2*10**5
  
  min_x = float("inf")
  max_x = -float("inf")
  min_y = float("inf")
  max_y = -float("inf")
  
  min_x_pos = []
  max_x_pos = []
  min_y_pos = []
  max_y_pos = []
  
  for i in range(n):
      x, y = map(int, input().split())
      # x, y = (10**9 , 10**9)
      if x < min_x:
          min_x = x
          min_x_pos = [(x, y)]
      elif x == min_x:
          min_x_pos.append((x, y))
  
      if y < min_y:
          min_y = y
          min_y_pos = [(x, y)]
      elif y == min_y:
          min_y_pos.append((x, y))
  
      if x > max_x:
          max_x = x
          max_x_pos = [(x, y)]
      elif x == max_x:
          max_x_pos.append((x, y))
      if y > max_y:
          max_y = y
          max_y_pos = [(x, y)]
      elif y == max_y:
          max_y_pos.append((x, y))
  
  
  def calc_dist(pos1, pos2):
      return abs(pos1[0] - pos2[0]) + abs(pos1[1] - pos2[1])
  
  
  min_x_of_max_y = max(min_x_pos, key=lambda pos: pos[1])
  min_x_of_min_y = min(min_x_pos, key=lambda pos: pos[1])
  
  min_y_of_max_x = max(min_y_pos, key=lambda pos: pos[0])
  min_y_of_min_x = min(min_y_pos, key=lambda pos: pos[0])
  
  max_x_of_max_y = max(max_x_pos, key=lambda pos: pos[1])
  max_x_of_min_y = min(max_x_pos, key=lambda pos: pos[1])
  
  max_y_of_max_x = max(max_y_pos, key=lambda pos: pos[0])
  max_y_of_min_x = min(max_y_pos, key=lambda pos: pos[0])
  
  candidate_pos = [
      min_x_of_max_y,
      min_y_of_max_x,
      min_y_of_min_x,
      min_y_of_max_x,
      max_x_of_min_y,
      max_x_of_max_y,
      max_y_of_min_x,
      max_y_of_max_x,
  ]
  
  answer = 0
  for i in range(len(candidate_pos)):
      for j in range(len(candidate_pos)):
          dis = calc_dist(candidate_pos[i], candidate_pos[j])
          answer = max(answer, dis)
  
  print(answer)
  
problem_description: Statement
  
  There are N points on the 2D plane, i-th of which is located on (x_i, y_i).
  There can be multiple points that share the same coordinate. What is the
  maximum possible Manhattan distance between two distinct points?
  
  Here, the _Manhattan distance_ between two points (x_i, y_i) and (x_j, y_j) is
  defined by |x_i-x_j| + |y_i-y_j|.
samples: [{"input": "3\n    1 1\n    2 4\n    3 2", "output": "4\n    \n\nThe Manhattan distance between the first point and the second point is\n|1-2|+|1-4|=4, which is maximum possible.\n\n* * *"}, {"input": "2\n    1 1\n    1 1", "output": "0"}]