input: from typing import List
  from math import inf
  from heapq import nlargest, nsmallest
  
  def smallest_max_distance_after_point_removal(coordinates: List[List[int]]) -> int:
      """
      Given an array coordinates representing integer positions on a 2D grid, where coordinates[i] = [x_i, y_i].
  
      The Manhattan distance defines the distance between two points.
      Find the minimum achievable value for the maximum distance between any two points by removing one point exactly.
  
      Examples:
      >>> coordinates = [[3,10],[5,15],[10,2],[4,4]]
      12
      >>> coordinates = [[1,1],[1,1],[1,1]]
      0
  
      Constraints:
      3 <= coordinates.length <= 10^5
      coordinates[i].length == 2
      1 <= coordinates[i][0], coordinates[i][1] <= 10^8
      """
output:     def manhattan(p1, p2):
          return abs(p1[0] - p2[0]) + abs(p1[1] - p2[1])
      
      n = len(coordinates)
      
      if n == 3:
          return min(manhattan(coordinates[0], coordinates[1]), 
                     manhattan(coordinates[1], coordinates[2]), 
                     manhattan(coordinates[0], coordinates[2]))
      
      def max_manhattan(coors):
          xs = [x for x, y in coors]
          ys = [y for x, y in coors]
          min_x, max_x = min(xs), max(xs)
          min_y, max_y = min(ys), max(ys)
          return manhattan((min_x, min_y), (max_x, max_y))
  
      initial_max_distance = max_manhattan(coordinates)
  
      min_distance_after_removal = inf
      
      for i in range(n):
          coors = coordinates[:i] + coordinates[i+1:]
          max_distance = max_manhattan(coors)
          min_distance_after_removal = min(min_distance_after_removal, max_distance)
      
      return min_distance_after_removal