Lee is going to fashionably decorate his house for a party, using some regular convex polygons...

Lee thinks a regular n-sided (convex) polygon is beautiful if and only if he can rotate it in such a way that at least one of its edges is parallel to the OX-axis and at least one of its edges is parallel to the OY-axis at the same time.

Recall that a regular n-sided polygon is a convex polygon with n vertices such that all the edges and angles are equal.

Now he is shopping: the market has t regular polygons. For each of them print YES if it is beautiful and NO otherwise.

Input

The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of polygons in the market. 

Each of the next t lines contains a single integer n_i (3 ≤ n_i ≤ 10^9): it means that the i-th polygon is a regular n_i-sided polygon. 

Output

For each polygon, print YES if it's beautiful or NO otherwise (case insensitive).

Example

Input


4
3
4
12
1000000000


Output


NO
YES
YES
YES

Note

In the example, there are 4 polygons in the market. It's easy to see that an equilateral triangle (a regular 3-sided polygon) is not beautiful, a square (a regular 4-sided polygon) is beautiful and a regular 12-sided polygon (is shown below) is beautiful as well.

<image>
import math

# def binsearch(arr,x,l,r):
# 	n = len(arr)
# 	if l>r:
# 		return -1
# 	else:
# 		m = (r+l)//2
# 		mid = arr[(l+r)//2]
# 		if mid==x:
# 			return (l+r)//2
# 		else:
# 			if mid>x:
# 				return binsearch(arr,x,l,m-1)
# 			else:
# 				return binsearch(arr,x,m+1,r)

#Sieve (all prime numbers till n)
# import math
# n = 10
# p = 2
# t = [False]*(n+1)
# while p<=int(math.sqrt(n)):
# 	print(p)
# 	if not t[p]:
# 		for i in range(p**2, n+1,p):
# 			t[i] = True
# 	p+=1
# # print(t)
# primes = [i for i in range(len(t)) if not t[i]]
# primes.pop(0)
# primes.pop(0)
# print(primes)


# Sieve (least prime factor of a number)
# least = [0]*(n+1)
# least[1] = 1
# for i in range(2,n+1):
# 	if not least[i] :
# 		least[i] = i
# 		for j in range(2*i,n+1,i):
# 			if not least[j] :
# 				least[j] = i

# print(least)
#Sieve (prime factorization)
# def pf(x):
# 	r = []
# 	while x!=1:
# 		r.append(least[x])
# 		x//=least[x]
# 	return r


#Efficient power(x,n)
# def pow(x,n):
# 	if n==0:
# 		return 1
# 	p = pow(x,n//2)
# 	if n%2==0:
# 		return p*p
# 	else:
# 		return x*p*p
# x,n = map(int,input().split())
# ans = pow(x,abs(n))
# if n<0:
# 	print(1/ans)
# else:
# 	print(ans)
# k = int(input())
# s = list('codeforces')


#All Divisors of n
# def alldiv(n):
# 	r = []
# 	for i in range(1,int(math.sqrt(n))+1):
# 		if n%i==0:
# 			if n//i == i:
# 				r.append(i)
# 			else:
# 				r.append(i)
# 				r.append(n//i)
# 	return len(r)
#Prime Fact > 10**5
# def pf(x):
# 	r = [1]
# 	while x%2==0:
# 		r.append(2)
# 		x//=2
# 	for i in range(3,int(math.sqrt(x))+1,2):
# 		while x%i==0:
# 			r.append(i)
# 			x//=i
# 	if x>2:
# 		r.append(x)
# 	return r
# isPrime
# def prime(x):
# 	r = []
# 	if x==2:
# 		return True
# 	elif x==3:
# 		return True
# 	for i in range(2,int(math.sqrt(x))+1):
# 		if x%i==0:
# 			return False
# 	return True

# A = [2, 4, 6]
# A.sort()
# b = []
# for i in A:
# 	c = bin(i)
# 	c = '0'*(30-len(c[2:])) + c[2:]
# 	b.append(c)
# ans = 0
# for i in range(30):
# 	zer = 0
# 	one = 0
# 	for j in b:
# 		if j[i]=='0':
# 			zer+=1
# 		else:
# 			one+=1
# 	ans+= (2*zer*one)%1000000007

#Sieve (all prime numbers till n)
# n = 10**6
# l = [i for i in range(2,n+1)]
# l = [0,1] + l
# p = 2
# t = [False]*len(l)
# while p**2<=n:
# 	if not t[p]:
# 		for i in range(p**2, n+1,p):
# 			t[i] = True
# 	p+=1
# primes = {}
# for i in range(2,len(t)):
# 	if not t[i]:
# 		primes[i] = 1

#primes
# def isPrime(n) : 
#     # Corner cases 
#     if (n <= 1) : 
#         return False
#     if (n <= 3) : 
#         return True
   
#     # This is checked so that we can skip  
#     # middle five numbers in below loop 
#     if (n % 2 == 0 or n % 3 == 0) : 
#         return False
   
#     i = 5
#     while(i * i <= n) : 
#         if (n % i == 0 or n % (i + 2) == 0) : 
#             return False
#         i = i + 6
   
#     return True 
# n = 10**6
# primes = {}
# for i in range(2,n+1):
# 	if isPrime(i):
# 		primes[i] = 1
# primes = [i for i in range(len(t)) if not t[i]]
# primes.pop(0)
# primes.pop(0)
# print(primes)


# def gcd(a,b): 
      
#     # Everything divides 0  
#     if (b == 0): 
#          return a 
#     return gcd(b, a%b) 

# def gcd(a,b):
# 	if a==0:
# 		return b
# 	if b==0:
# 		return a
# 	if a==b:
# 		return a
# 	if a>b:
# 		return gcd(a-b,b)
# 	return gcd(a,b-a)


#All subarrays
# def subarr(A,subs):
# 	s = 0
# 	e = 0
# 	for i in range(len(A)):
# 		if e==len(A):
# 			break
# 		for j in range(s,e+1):
# 			subs.append(A[s:e+1])
# 			s+=1
# 		if s>e:
# 			s = 0
# 		e+=1

# A = int('-0000813280700')
# print(binsearch(primes,8))

# global ans
# ans = 0
# def fun(i,j,n,m):
# 	if i==n-1 or j==m-1:
# 		return 1
# 	return fun(i+1,j,n,m) + fun(i,j+1,n,m)

# n,m = 4,4
# print(fun(0,0,n,m))

# a = set()
# def per(s,l,r):
# 	if l==r:
# 		a.add(''.join(s))
# 	else:
# 		for i in range(l,r+1):
# 			s[l],s[i] = s[l],s[i]
# 			per(s,l+1,r)
# 			s[l],s[i] = s[i],s[l]


# A = 'baa'
# per(list(A),0,len(A)-1)
# a = list(a)
# a.sort()
# print(binsearch(a,A,0,len(a)-1)+1)
# A = [1,6,2,4,5]
# print(binsearch(A,3,0,len(A)-1))
# def dfs(ans,vis,u,edge):
# 	vis[u] = True
# 	visited[u] = True
# 	ans.append(u+1)
# 	for i in edge[u]:
# 		if not vis[i]:
# 			ans = dfs(ans,vis,i,edge)
# 	return ans



# def bfs(vis,u,edge):
# 	vis[u] = True
# 	q = [u]
# 	ans = [u+1]
# 	while q:
# 		x = q.pop(0)
# 		for i in edge[x]:
# 			if not vis[i]:
# 				q.append(i)
# 				ans.append(i+1)
# 				visited.discard(i)
# 				vis[i] = True
# 		del edge[x]
# 	return ans

# for _ in range(int(input())):
# 	n,m = map(int,input().split())
# 	a = list(map(int,input().split()))
# 	b = list(map(int,input().split()))
# 	edgeinp = []
# 	for i in range(m):
# 		x,y = map(int,input().split())
# 		x-=1
# 		y-=1
# 		edgeinp.append([x,y])
# 	# print(edge)
# 	# print(pc)
# 	pc = [a[i]/b[i] for i in range(n)]
# 	maxx = max(pc)
# 	edge = {}
# 	for i in mn:
# 		edge[i] = []
# 	for i in edgeinp:
# 		x = i[0]
# 		y = i[1]
# 		if pc[x]==pc[y]==maxx:
# 			edge[x].append(y)
# 			edge[y].append(x)
# 	visited = set()
# 	for i in range(n):
# 		if pc[i]==maxx:
# 			visited.add(i)
# 	ans = []
# 	while visited:
# 		x = visited.pop()
# 		vis = [False]*n
# 		h = bfs(vis,x,edge)
# 		if len(h)>len(ans):
# 			ans = h
# 	# print(vis)
# 	print(int(maxx))
# 	print(*ans)
	# print(*ans)

# def smaller(arr,x,ans,l,h):
# 	# n = len(arr)
# 	# print(l,h)
# 	if l>h:
# 		return ans
# 	else:
# 		mid = arr[(l+h)//2]
# 		if mid<x:
# 			ans+=len(arr[l:(l+h)//2+1])
# 			return smaller(arr,x,ans,(l+h)//2+1,h)
# 		else:
# 			# print(arr[:mid])
# 			return smaller(arr,x,ans,l,(l+h)//2-1)

for _ in range(int(input())):
	n = int(input())
	if n%4==0:
		print('YES')
	else:
		print("NO")