import bisect

def main():
    import sys
    input = sys.stdin.read
    data = input().split()
    n = int(data[0])
    points = []
    index = 1
    for i in range(n):
        x = int(data[index])
        y = int(data[index + 1])
        index += 2
        u = x + y
        v = x - y
        points.append((x, y, u, v))
    
    # Precompute sorted lists and their values for u and v
    sorted_u = sorted(points, key=lambda p: p[2])
    u_values = [p[2] for p in sorted_u]
    sorted_v = sorted(points, key=lambda p: p[3])
    v_values = [p[3] for p in sorted_v]
    
    max_u = max(p[2] for p in points)
    min_u = min(p[2] for p in points)
    max_v = max(p[3] for p in points)
    min_v = min(p[3] for p in points)
    
    k = 5  # Adjusting k to 5 for better coverage
    min_p = float('inf')
    
    for point in points:
        x, y, u, v = point
        
        # Collect candidates from sorted_u
        idx_u = bisect.bisect_left(u_values, u)
        start = max(0, idx_u - k)
        end = min(len(sorted_u) - 1, idx_u + k)
        candidates = []
        for j in range(start, end + 1):
            candidates.append(sorted_u[j])
        
        # Collect candidates from sorted_v
        idx_v = bisect.bisect_left(v_values, v)
        start_v = max(0, idx_v - k)
        end_v = min(len(sorted_v) - 1, idx_v + k)
        for j in range(start_v, end_v + 1):
            candidates.append(sorted_v[j])
        
        # Calculate min_dist
        min_dist = float('inf')
        for p in candidates:
            if p == point:
                continue
            du = abs(u - p[2])
            dv = abs(v - p[3])
            current = max(du, dv)
            if current < min_dist:
                min_dist = current
        
        # Calculate max_dist
        max_u_cur = max(max_u - u, u - min_u)
        max_v_cur = max(max_v - v, v - min_v)
        max_dist = max(max_u_cur, max_v_cur)
        
        # Compute P_i
        p_i = abs(max_dist - min_dist)
        if p_i < min_p:
            min_p = p_i
    
    print(min_p)

if __name__ == "__main__":
    main()