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/c2
# tag: geometry, trichotomy
# difficulty: difficult
from typing import List
from math import tan, pi, cos, sin

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 __add__(self, other):
        return Point(self.x + other.x, self.y + other.y)

    def dot(self, other):
        """
        dot product of self and other
        """
        return self.x * other.x + self.y * other.y

    def cross(self, other):
        """
        cross product of self and other
        """
        return self.x * other.y - self.y * other.x

    def abs(self):
        """
        Distance of self to origin
        :return:
        """
        return self.dot(self) ** 0.5

    def dist(self, other):
        """
        :param other: other
        :return: euclidean distance of self and other
        """
        return (self - other).abs()

    def __mul__(self, scale):
        return Point(self.x * scale, self.y * scale)

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


class Segment:
    def __init__(self, pt1: Point, pt2: Point):
        self.pt1 = pt1
        self.pt2 = pt2

    def intersect(self, other):
        """

        :param other:
        :return: (point, t), point is intersection point, and pt1 + t*(pt2-pt1)=point, (None,None) means parallel
        """
        v: Point = self.pt2 - self.pt1
        w: Point = other.pt2 - other.pt1
        if v.cross(w) == 0:
            return None, None
        u: Point = self.pt1 - other.pt1
        t = w.cross(u) / v.cross(w)
        return self.pt1 + v * t, t


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("%s" % (1 / (2 * sin(pi / (4 * k)))))