Read problem statement in Mandarin chinese and Vietnamese. 

Suzumo is the coach of the ChefLand OI team. Physical condition is very important in any olympiad, so he wants to make the children run a bit as a warmup.

The team consists of $N$ children numbered $1$ through $N$ standing at some positions on the $x$-axis. For each valid $i$, the initial $x$-coordinate of the $i$-th kid is $x_{i}$, the running velocity of the $i$-th kid is constant and equal to $v_{i}$.

Suzumo wants to assign a running direction (left or right, i.e. in the direction of decreasing or increasing $x$-coordinate) to each kid; the children start running at time $0$ in the assigned directions. Afterwards, Suzumo will measure the smallest time $t$ at which some kid passes another one. Help Suzumo compute the maximum time $t$ if he can assign the directions arbitrarily!

Note: Child $i$ *passes* child $j$ at time $t_{ij}$ if their coordinates satisfy $x_{i} < x_{j}$ at any time $t < t_{ij}$ and $x_{i} > x_{j}$ at any time $t > t_{ij}$, or if they satisfy $x_{i} > x_{j}$ at any time $t < t_{ij}$ and $x_{i} < x_{j}$ at any time $t > t_{ij}$.

------  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 line of each test case contains a single integer $N$.
$N$ lines follow. For each valid $i$, the $i$-th of these lines contains two space-separated integers $x_{i}$ and $v_{i}$.

------  Output ------

For each test case, print a single line containing one real number — the maximum possible time $t$, or $-1$ if it is possible to assign directions in such a way that no kid ever passes another. Your answer will be considered correct if it has an absolute or relative error less than or equal to $10^{-6}$.

------  Constraints  ------
$1 ≤ T ≤ 100$
$1 ≤ N ≤ 50$
$1 ≤ x_{i}, v_{i} ≤ 10^{9}$ for each valid $i$
no two children have the same initial positions

----- Sample Input 1 ------ 
1
3
10 10
20 30
30 10
----- Sample Output 1 ------ 
0.5
----- explanation 1 ------ 
Example case 1: One optimal assignment of directions is left, right, right.

Difficulty: VERY_HARD

Solutions:
LEFT = 0
RIGHT = 1
T = int(input())
coordinates = None

def f():
	ans = [[100000000000.0, 100000000000.0]]
	for i in range(1, len(coordinates)):
		ans.append([0, 0])
		distance = coordinates[i][0] - coordinates[i - 1][0]
		velocity = coordinates[i][1] + coordinates[i - 1][1]
		time_taken = distance / velocity
		ans[i][LEFT] = max(ans[i][LEFT], min(ans[i - 1][RIGHT], time_taken))
		velocity = coordinates[i - 1][1] - coordinates[i][1]
		if velocity > 0:
			time_taken = distance / velocity
			ans[i][RIGHT] = max(ans[i][RIGHT], min(ans[i - 1][RIGHT], time_taken))
		else:
			ans[i][RIGHT] = max(ans[i][RIGHT], ans[i - 1][RIGHT])
		velocity = coordinates[i][1] - coordinates[i - 1][1]
		if velocity > 0:
			time_taken = distance / velocity
			ans[i][LEFT] = max(ans[i][LEFT], min(ans[i - 1][LEFT], time_taken))
		else:
			ans[i][LEFT] = max(ans[i][LEFT], ans[i - 1][LEFT])
		ans[i][RIGHT] = max(ans[i][RIGHT], ans[i - 1][LEFT])
	return ans[-1][RIGHT]
for t in range(T):
	N = int(input())
	coordinates = [tuple(map(int, input().split())) for _ in range(N)]
	coordinates.sort()
	answer = f()
	if answer == 100000000000.0:
		answer = -1
	print(answer)


for query in range(int(input())):
	n = int(input())
	child = []
	for i in range(n):
		child.append([int(v) for v in input().split()])
	child.sort()
	d = [float('inf'), float('inf')]
	for i in range(1, n):
		if child[i][1] <= child[i - 1][1]:
			left_left = d[0]
		else:
			left_left = min(d[0], (child[i][0] - child[i - 1][0]) / float(child[i][1] - child[i - 1][1]))
		left_right = d[0]
		right_left = min((child[i][0] - child[i - 1][0]) / float(child[i][1] + child[i - 1][1]), d[1])
		if child[i][1] >= child[i - 1][1]:
			right_right = d[1]
		else:
			right_right = min(d[1], (child[i][0] - child[i - 1][0]) / float(child[i - 1][1] - child[i][1]))
		d = [max(left_left, right_left), max(left_right, right_right)]
	if max(d) == float('inf'):
		print(-1)
	else:
		print(max(d))


import math
tc = int(input())
while tc > 0:
	n = int(input())
	children = []
	for i in range(n):
		temp = list(map(int, input().split()))
		children.append(temp)
	children.sort()
	data = [math.inf, math.inf]
	for i in range(1, n):
		if children[i - 1][1] >= children[i][1]:
			ll = data[0]
		else:
			ll = min(data[0], (children[i][0] - children[i - 1][0]) / float(children[i][1] - children[i - 1][1]))
		rl = min(data[1], (children[i][0] - children[i - 1][0]) / float(children[i][1] + children[i - 1][1]))
		lr = data[0]
		if children[i - 1][1] <= children[i][1]:
			rr = data[1]
		else:
			rr = min(data[1], (children[i][0] - children[i - 1][0]) / float(children[i - 1][1] - children[i][1]))
		data = [max(ll, rl), max(lr, rr)]
	if max(data) is math.inf:
		print(-1)
	else:
		print(max(data))
	tc -= 1


from math import ceil, log
t = int(input())
for test in range(t):
	n = int(input())
	arr = [[-1, -1]]
	for i in range(n):
		arr.append(list(map(int, input().split())))
	if n == 1:
		print(-1)
		continue
	arr.sort()
	ans = [None, (int(2000000000.0), int(2000000000.0))]
	for i in range(2, n + 1):
		tmp = int(2000000000.0)
		if arr[i - 1][1] < arr[i][1]:
			tmp = (arr[i][0] - arr[i - 1][0]) / (arr[i][1] - arr[i - 1][1])
		tmp2 = (arr[i][0] - arr[i - 1][0]) / (arr[i][1] + arr[i - 1][1])
		tmp = min(ans[i - 1][0], tmp)
		tmp2 = min(ans[i - 1][1], tmp2)
		x = max(tmp, tmp2)
		tmp = int(2000000000.0)
		if arr[i - 1][1] > arr[i][1]:
			tmp = (arr[i][0] - arr[i - 1][0]) / (arr[i - 1][1] - arr[i][1])
		tmp = min(ans[i - 1][1], tmp)
		tmp2 = min(ans[i - 1][0], int(2000000000.0))
		y = max(tmp2, tmp)
		ans.append((x, y))
	if max(ans[-1]) == int(2000000000.0):
		print(-1)
	else:
		print(max(ans[-1]))