Come Together
Bob and Carol hanged out with Alice the whole day, but now it's time to go home. Alice, Bob and Carol live on an infinite 2D grid in cells $$$A$$$, $$$B$$$, and $$$C$$$ respectively. Right now, all of them are in cell $$$A$$$.If Bob (or Carol) is in some cell, he (she) can move to one of the neighboring cells. Two cells are called neighboring if they share a side. For example, the cell $$$(3, 5)$$$ has four neighboring cells: $$$(2, 5)$$$, $$$(4, 5)$$$, $$$(3, 6)$$$ and $$$(3, 4)$$$.Bob wants to return to the cell $$$B$$$, Carol — to the cell $$$C$$$. Both of them want to go along the shortest path, i. e. along the path that consists of the minimum possible number of cells. But they would like to walk together as well. What is the maximum possible number of cells that Bob and Carol can walk together if each of them walks home using one of the shortest paths?
In all pictures, red color denotes cells belonging only to Bob's path, light blue color — cells belonging only to Carol's path, and dark blue color — cells belonging to both paths.One of the optimal routes for the first test case is shown below:    Bob's route contains $$$5$$$ cells, Carol's route — $$$7$$$ cells, and they will visit $$$3$$$ cells together.The optimal answer for the second test case is shown below:    Bob's route contains $$$4$$$ cells, Carol's route — $$$3$$$ cells, and they will visit only $$$1$$$ cell together.One of the optimal answers for the third test case is shown below:    Bob's route contains $$$6$$$ cells, Carol's route — $$$9$$$ cells, and they will visit $$$6$$$ cells together.
The first line contains the single integer $$$t$$$ ($$$1 \le t \le 10^4$$$) — the number of test cases.The first line of each test case contains two integers $$$x_A$$$ and $$$y_A$$$ ($$$1 \le x_A, y_A \le 10^8$$$) — the position of cell $$$A$$$, where both Bob and Carol are right now.The second line contains two integers $$$x_B$$$ and $$$y_B$$$ ($$$1 \le x_B, y_B \le 10^8$$$) — the position of cell $$$B$$$ (Bob's house).The third line contains two integers $$$x_C$$$ and $$$y_C$$$ ($$$1 \le x_C, y_C \le 10^8$$$) — the position of cell $$$C$$$ (Carol's house).Additional constraint on the input: the cells $$$A$$$, $$$B$$$, and $$$C$$$ are pairwise distinct in each test case.
For each test case, print the single integer — the maximum number of cells Bob and Carol can walk together if each of them goes home along one of the shortest paths.
def main():

    def solve(xa, ya, xb, yb, xc, yc):
        dxba = xb - xa
        dyba = yb - ya
        dxca = xc - xa
        dyca = yc - ya
        ret = 0
        if dxba * dxca > 0:
            ret += min(abs(dxba), abs(dxca))
        if dyba * dyca > 0:
            ret += min(abs(dyba), abs(dyca))
        return ret + 1
    t = int(input())
    ans = []
    for _ in range(t):
        (xa, ya) = [int(x) for x in input().split()]
        (xb, yb) = [int(x) for x in input().split()]
        (xc, yc) = [int(x) for x in input().split()]
        ans.append(solve(xa, ya, xb, yb, xc, yc))
    print('\n'.join(map(str, ans)))
if __name__ == '__main__':
    import sys, threading
    input = sys.stdin.readline
    thread = threading.Thread(target=main)
    thread.start()
    thread.join()
def main():

    def solve(xa, ya, xb, yb, xc, yc):
        dxba = xb - xa
        dyba = yb - ya
        dxca = xc - xa
        dyca = yc - ya
        ret = 0
        v = h = False
        if dxba * dxca > 0:
            ret += min(abs(dxba), abs(dxca)) + 1
            h = True
        if dyba * dyca > 0:
            ret += min(abs(dyba), abs(dyca)) + 1
            v = True
        if v and h:
            ret -= 1
        if ret == 0:
            ret = 1
        return ret
    t = int(input())
    ans = []
    for _ in range(t):
        (xa, ya) = [int(x) for x in input().split()]
        (xb, yb) = [int(x) for x in input().split()]
        (xc, yc) = [int(x) for x in input().split()]
        ans.append(solve(xa, ya, xb, yb, xc, yc))
    print('\n'.join(map(str, ans)))
if __name__ == '__main__':
    import sys, threading
    input = sys.stdin.readline
    thread = threading.Thread(target=main)
    thread.start()
    thread.join()
import sys
input = sys.stdin.readline

def dist(a, b, c):
    if b > c:
        (b, c) = (c, b)
    if b <= a <= c:
        return 0
    if a <= b <= c:
        return abs(b - a)
    if b <= c <= a:
        return abs(c - a)

def solve():
    (Ax, Ay) = map(int, input().split())
    (Bx, By) = map(int, input().split())
    (Cx, Cy) = map(int, input().split())
    w = dist(Ax, Bx, Cx)
    h = dist(Ay, By, Cy)
    print(w + h + 1)
t = int(input())
for _ in range(t):
    solve()