Chef got in the trouble! He is the king of Chefland and Chessland. There is one queen in Chefland and one queen in Chessland and they both want a relationship with him. Chef is standing before a difficult choice…
Chessland may be considered a chessboard with $N$ rows (numbered $1$ through $N$) and $M$ columns (numbered $1$ through $M$). Let's denote a unit square in row $r$ and column $c$ by $(r, c)$. Chef lives at square $(X, Y)$ of this chessboard.
Currently, both queens are living in Chessland too. Each queen, when alone on the chessboard, can see all squares that lie on the same row, column or diagonal as itself. A queen from $(x_q, y_q)$ cannot see a square $(r, c)$ if the square $(X, Y)$ is strictly between them. Of course, if the queens can see each other, the kingdom will soon be in chaos!
Help Chef calculate the number of possible configurations of the queens such that the kingdom will not be in chaos. A configuration is an unordered pair of distinct squares $(x_{q1}, y_{q1})$ and $(x_{q2}, y_{q2})$ such that neither of them is the square $(X, Y)$. Two configurations are different if the position of queen $1$ is different or the position of queen $2$ is different.

-----Input-----
- The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows.
- The first and only line of each test case contains four space-separated integers $N$, $M$, $X$ and $Y$. 

-----Output-----
For each test case, print a single line containing one integer — the number of configurations such that the kingdom will not be in chaos.

-----Constraints-----
- $1 \le T \le 1000$
- $1 \le X \le N \le 10^2$
- $1 \le Y \le M \le 10^2$
- $2 \le N, M$

-----Example Input-----
2
3 3 2 2
4 4 2 3

-----Example Output-----
24
94

-----Explanation-----
Example case 1: Half of these configurations are:
- $(1, 1), (3, 3)$
- $(1, 1), (2, 3)$
- $(1, 1), (3, 2)$
- $(1, 2), (3, 3)$
- $(1, 2), (3, 2)$
- $(1, 2), (3, 1)$
- $(1, 3), (3, 1)$
- $(1, 3), (3, 2)$
- $(1, 3), (2, 1)$
- $(2, 1), (2, 3)$
- $(2, 1), (1, 3)$
- $(2, 1), (3, 3)$

Starter code:

Solutions:
def C(n):
 return n*(n-1)//2


def sol():
 equal, mini = False, min(N,M)
 total_ways = 2*C(N * M)
 if N==M:
  equal = True
 ways = 0
 if not equal:
  ways = (N*C(M)+M*C(N))
  diag = 0
  for i in range(2, mini+1):
   diag += 2*C(i)
  for i in range(mini+1,max(N,M)):
   diag += C(mini)
  diag *= 2
  ways += diag
  ways *= 2
 else:
  ways = (N*C(M)+M*C(N))
  diag = 0
  for i in range(2, mini):
   diag += 2*C(i)
  diag += C(mini)
  diag *= 2
  ways += diag
  ways *=2
 safe = total_ways - ways
 l, r, t, d = Y-1, M-Y, X-1, N-X
 safe_add, to_remove = 0, 0

 for i in range(1,N+1):
  for j in range(1, M+1):
   if i==X or j==Y or abs(i-X)==abs(j-Y):
    continue
   else:
    to_remove += 1

 if l>0 and r>0 and t>0 and d>0:
  dtl, dtr, dbl, dbr = min(l,t), min(r,t), min(l,d), min(r,d)
  safe_add += dtl*dbr*2 + dtr*dbl*2
  safe_add += t*d*2
  safe_add += l*r*2
 elif l>0 and r>0:
  safe_add += l*r*2
 elif t>0 and d>0:
  safe_add += t*d*2

 safe += safe_add - to_remove*2

 return safe


T = int(input())
for _ in range(T):
 N, M, X, Y = [int(x) for x in input().split()]
 print(sol())


def solve(N,M,x,y):
 n,m=min(N,M),max(N,M)

 count = ((n-1)*n*(2*n-1)//3 + (m-n+1)*n**2 ) * 2 ## total sum of l_d and         r_d at all places
 p1,p2 = min(x-1,y-1),min(N-x,M-y)
 r1,r2 = min(M-y,x-1),min(N-x,y-1)
 #print('-->',p1,p2,r1,r2)
 count += (n+m)*n*m ## total sum of places queen 2 cannt have at all cells         including kings cell
 #print('1',count)

 count -= p1+p2+r1+r2 + n+m + 2 ## place occupied by king cannot be         occupied by queen
 #print('2',count)
 
 count += (n*m)-(p1+p2+r1+r2 + n + m -1) ##  total count where queen 2 cannot         come
 #print('3',count)

 count -= (n*m-1)*3 ## total count where queen 2 cannot come where centre is         counted once
 #print('4',count)
 tot = (n*m-1)*n*m - count
 #print(tot)
 tot += 2*(p1*p2 + r1*r2 + (x-1)*(N-x) + (y-1)*(M-y))

 return tot
 

for _ in range(int(input())):

 n,m,x,y = list(map(int,input().split()))
 print(solve(n,m,x,y))


def ncr(n, r): 
 if n < r :
  return 0
 elif r == 2:
  return(n*(n-1)/2)
 elif r == 1:
  return n
 else:
  t = 0

t = int(input())
for p in range(t):
 n,m,x,y = input().split()
 n,m,x,y = int(n),int(m),int(x),int(y)

 maxi = ncr(n*m-1,2)

 sub1 = ncr(n,2) * (m-1)
 sub2 = ncr(m,2) * (n-1)
 maxi = maxi - (sub1 + sub2)
 #print(maxi)

 sub3 = ncr(y-1,2) + ncr(m-y,2)
 sub4 = ncr(x-1,2) + ncr(n-x,2)
 #print(sub3,sub4)
 maxi = maxi - (sub3 + sub4)
 #print(maxi)

 if n < m:
  temp = n
  diff = m-n
 else:
  temp = m
  diff = n-m

 sub5 = 0
 sub6 = 0
 for i in range(2,temp):
  sub5 += ncr(i,2)

 for j in range(diff+1):
  sub6 += ncr(temp,2)

 sub5 *= 4
 sub6 *= 2

 #print(sub5,sub6)
 maxi = maxi - (sub5 + sub6)
 #print(maxi)

 l1 = min(n-x,y-1)
 l2 = min(m-y,x-1)
 maxi = maxi + l1 + l2 + (l1*l2)


 l3 = min(x-1,y-1)
 l4 = min(m-y,n-x)
 maxi = maxi + l3 + l4 + (l3*l4)

 print(int(maxi*2))