Problem: The statement of this problem is the same as the statement of problem C2. The only difference is that, in problem C1, n is always even, and in C2, n is always odd.

You are given a regular polygon with 2 ⋅ n vertices (it's convex and has equal sides and equal angles) and all its sides have length 1. Let's name it as 2n-gon.

Your task is to find the square of the minimum size such that you can embed 2n-gon in the square. Embedding 2n-gon in the square means that you need to place 2n-gon in the square in such way that each point which lies inside or on a border of 2n-gon should also lie inside or on a border of the square.

You can rotate 2n-gon and/or the square.

Input

The first line contains a single integer T (1 ≤ T ≤ 200) — the number of test cases.

Next T lines contain descriptions of test cases — one per line. Each line contains single even integer n (2 ≤ n ≤ 200). Don't forget you need to embed 2n-gon, not an n-gon.

Output

Print T real numbers — one per test case. For each test case, print the minimum length of a side of the square 2n-gon can be embedded in. Your answer will be considered correct if its absolute or relative error doesn't exceed 10^{-6}.

Example

Input


3
2
4
200


Output


1.000000000
2.414213562
127.321336469

Solution (in PYTHON3):

Solution:
# url: https://codeforces.com/contest/1354/problem/c1
# tag:
# difficulty:
from typing import List
from math import tan, pi

INF = float("inf")
NINF = float("-inf")


def read_string():
    return input()


def read_string_line():
    return [x for x in input().split(" ")]


def read_int_line():
    return [int(x) for x in input().split(" ")]


def read_int():
    return int(input())


def get_int_arr(s):
    return [int(x) for x in s.split()]


def get_sum(acc, l, r):
    """
     l, r are original index
     """
    return acc[r] - acc[l]


P = int(1e9 + 7)


def exgcd(x, y):
    if y == 0:
        return x, 1, 0
    g, a, b = exgcd(y, x % y)
    t = x // y
    return g, b, a - t * b


def inv(x):
    g, a, b = exgcd(x, P)
    return a


def calc_acc(arr):
    ans = [0]
    for a in arr:
        ans.append(a + ans[-1])
    return ans


class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def __sub__(self, other):
        return Point(self.x - other.x, self.y - other.y)

    def dot(self, other):
        return self.x * other.x + self.y * other.y

    def cross(self, other):
        return self.x * other.y - self.y * other.x

    def abs(self):
        return self.abs2() ** 0.5

    def abs2(self):
        return self.dot(self)

    def __str__(self):
        return "Point(%s, %s)" % (self.x, self.y)


def get_point(line):
    x, y = get_int_arr(line)
    return Point(x, y)


lines: List[str] = [*open(0)]
n = int(lines[0])
for line in lines[1:1 + n]:
    k = int(line)
    print(1 / tan(pi / (2 * k)))