input: from typing import List
  from math import inf
  from heapq import nlargest, nsmallest
  
  def minimum_distance_after_removing_one_point(points: List[List[int]]) -> int:
      """
      Given an array of points representing integer coordinates on a 2D plane, where each points[i] = [x_i, y_i].
  
      The Manhattan distance between any two points is defined as their distance in grid steps.
      Return the minimum possible value for the maximum distance between any two points by removing exactly one point.
  
      Examples:
      >>> points = [[3,10],[5,15],[10,2],[4,4]]
      12
      >>> points = [[1,1],[1,1],[1,1]]
      0
  
      Constraints:
      3 <= len(points) <= 100,000
      len(points[i]) == 2
      1 <= points[i][0], points[i][1] <= 100,000,000
      """
output:     
      if len(points) <= 3:
          return 0
  
      def manhattan(p1, p2):
          return abs(p1[0] - p2[0]) + abs(p1[1] - p2[1])
  
      min_dist = inf
  
      def largest_distances(points):
          x_values = [p[0] for p in points]
          y_values = [p[1] for p in points]
          
          largest_x = nlargest(2, x_values)
          smallest_x = nsmallest(2, x_values)
          largest_y = nlargest(2, y_values)
          smallest_y = nsmallest(2, y_values)
          
          x_combinations = largest_x + smallest_x
          y_combinations = largest_y + smallest_y
          
          return [(x, y) for x in x_combinations for y in y_combinations]
  
      for i in range(len(points)):
          remaining_points = points[:i] + points[i+1:]
          candidate_distances = largest_distances(remaining_points)
          
          current_max_dist = max(manhattan(p1, p2) for p1 in candidate_distances for p2 in candidate_distances if p1 != p2)
          
          min_dist = min(min_dist, current_max_dist)
          
      return min_dist
  