human
A penguin Rocher has n sticks. He has exactly one stick with length i for all 1 ≤ i ≤ n.

He can connect some sticks. If he connects two sticks that have lengths a and b, he gets one stick with length a + b. Two sticks, that were used in the operation disappear from his set and the new connected stick appears in his set and can be used for the next connections.

He wants to create the maximum number of sticks that have the same length. It is not necessary to make all sticks have the same length, some sticks can have the other length. How many sticks with the equal length he can create?

Input

The input consists of multiple test cases. The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases. Next t lines contain descriptions of test cases.

For each test case, the only line contains a single integer n (1 ≤ n ≤ 10^{9}).

Output

For each test case, print a single integer — the answer to the problem.

Example

Input

4
1
2
3
4

Output

1
1
2
2

Note

In the third case, he can connect two sticks with lengths 1 and 2 and he will get one stick with length 3. So, he will have two sticks with lengths 3.

In the fourth case, he can connect two sticks with lengths 1 and 3 and he will get one stick with length 4. After that, he will have three sticks with lengths \{2, 4, 4\}, so two sticks have the same length, and one stick has the other length.
assistant
#Here is Python code to print a single integer — the answer to the problem.

#!/usr/bin/env python3
from __future__ import division, print_function

import os
import sys
from io import BytesIO, IOBase

if sys.version_info[0] < 3:
    from __builtin__ import xrange as range
    from future_builtins import ascii, filter, hex, map, oct, zip

def main():
    # Base case 1 to 1 -> 1 
    # 2 -> 1 + 2 -> 3, [1,2], [3] [1,2]
    # k + l -> k+l or [k,l]
    # O(N) in recursive function,compare collections.Counter
    # [1,1,1,1] => 4 and Counter => 1 : 4 
    # max(collections.Counter.values()) -> O(N)
    # 3 -> [1,2,3] -> [3,3] => 2 
    # 4 -> [1,2,3,4] -> [4,4,2], []
    # If given N, I can always combine N -1 + 1 => N 
    # If given N, I can always combine N - 2  + 2 => N 
    # [1,2,3,4] -> [5,5] over [4,4,2] over [3,3,4] over [5,5]
    # [1,2,3,4,5] -> [5,5,5] over [3,4,4,5] over [3,3,4,5]
    # [1,2,3,4,5,6] -> [7,7,7] over [6,6,6,3] over [5,5,5,6] over [4,2,4,5,6]
    # n(n+1) /2 is the sum from 1..n
    # number of equal sticks will never be N 
    # [1,2,3,4,5,6,7,8] -> [9,9,9,9] 
    for _ in range(int(input())):
        n = int(input())
        if not n & 1:
            print(n // 2)
        else:
            print((n + 1) // 2)
        

# region fastio

BUFSIZE = 8192

class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr =...