You are given several queries. In the i-th query you are given a single positive integer ni. You are to represent ni as a sum of maximum possible number of composite summands and print this maximum number, or print -1, if there are no such splittings.

An integer greater than 1 is composite, if it is not prime, i.e. if it has positive divisors not equal to 1 and the integer itself.

Input

The first line contains single integer q (1 ≤ q ≤ 105) — the number of queries.

q lines follow. The (i + 1)-th line contains single integer ni (1 ≤ ni ≤ 109) — the i-th query.

Output

For each query print the maximum possible number of summands in a valid splitting to composite summands, or -1, if there are no such splittings.

Examples

Input

1
12


Output

3


Input

2
6
8


Output

1
2


Input

3
1
2
3


Output

-1
-1
-1

Note

12 = 4 + 4 + 4 = 4 + 8 = 6 + 6 = 12, but the first splitting has the maximum possible number of summands.

8 = 4 + 4, 6 can't be split into several composite summands.

1, 2, 3 are less than any composite number, so they do not have valid splittings.
import java.text.DecimalFormat;
import java.util.*;
import java.io.*;
import java.math.*;

public class Main {
	public static long mod = (long) (1e9 + 7);
	static InputReader s;
	static PrintWriter out;
	public static void main(String args[]) {
		new Thread(null, new Runnable() {
			public void run() {
				try {
					solve();
					out.flush();
					out.close();
				} catch (Exception e) {
					e.printStackTrace();
				}
			}
		}, "1", 1 << 26).start();
	}

	public static void solve() throws IOException {
		s = new InputReader(System.in);
		OutputStream outputStream = System.out;
		out = new PrintWriter(outputStream);
		Scanner sc = new Scanner(System.in);
		int q = s.nextInt();
		int a[]= new int[16];
		a[1] = -1;
		a[2] = -1;
		a[3] = -1;
		a[4] = 1;
		a[5] = -1;
		a[6] = 1;
		a[7] = -1;
		a[8] = 2;
		a[9] = 1;
		a[10] = 2;
		a[11] = -1;
		a[12] = 3;
		a[13] = 2;
		a[14] = 3;
		a[15] = 2;
		while(q-->0){
			int n = s.nextInt();
			if(n<=15){
				System.out.println(a[n]);
				continue;
			}
			if(n%4==0){
				System.out.println(n/4);
			}
			else if(n%4==1){
				n-=9;
				System.out.println(n/4+1);
			}
			else if(n%4==2){
				n-=6;
				System.out.println(n/4+1);
			}
			else{
				n-=15;
				System.out.println(n/4+2);
			}
		}
	}
	
	static long combinations(long n, long r) { // O(r)
		if (r == 0 || r == n)
			return 1;
		r = Math.min(r, n - r);
		long ans = n; // nC1=n;
		for (int i = 1; i < r; i++) {
			ans = (ans * (n - i));
			 ans= ans/(i+1);
//			ans = (ans * modulo(i + 1, mod - 2, mod)) % mod;
		}
		return ans;
	}

	static long modulo(long x, long y, long p) {
		long res = 1;
		x = x % p;

		while (y > 0) {
			if (y % 2 == 1)
				res = (res * x) % p;

			y = y >> 1;
			x = (x * x) % p;
		}
		return res;
	}

	static HashSet<Integer> primeFactors(int n) // O(sqrt(n))
	{
		// Print the number of 2s that divide n
		HashSet<Integer> arr = new HashSet<>();
		while (n % 2 == 0) {
			arr.add(2);
			n = n / 2;
		}

		// n must be odd at this point. So we can skip one element (Note i = i
		// +2)
		for (int i = 3; i <= Math.sqrt(n); i = i + 2) {
			// While i divides n, print i and divide n
			while (n % i == 0) {
				arr.add(i);
				n = n / i;
			}
		}
		// This condition is to handle the case when n is a prime number
		// greater than 2
		if (n > 2)
			arr.add(n);

		return arr;
	}

	public static long expo(long a, long b) {
		if (b == 0)
			return 1;
		if (b == 1)
			return a;
		if (b == 2)
			return a * a;

		if (b % 2 == 0) {
			return expo(expo(a, (b / 2)), 2);
		} else {
			return a * expo(expo(a, (b - 1) / 2), 2);
		}
	}

	static class Pair implements Comparable<Pair> {
		int a;
		int b;
		
		Pair(int aa, int bb) {
			a = aa;
			b = bb;
		}

		public int compareTo(Pair o) {
			int ans = Integer.compare(this.a, o.a);
			return ans;
			// return ans==0 ? -Integer.compare(this.b, o.b):ans;
			// if(Long.compare(this.x, o.x)!=0)
			// return -Long.compare(this.x, o.x);
			// else
			// return Long.compare(this.y, o.y);
			// return Integer.compare(this.x, o.x);
			// return Long.compare(this.x, o.x);
		}

//		public int hashCode() {
//			int hu = (int) (a ^ (a >>> 32));
//			int hv = (int) (b ^ (b >>> 32));
//			return 31 * hu + hv;
//		}

		//
		public boolean equals(Object o) {
			Pair other = (Pair) o;
			return a == other.a && b == other.b;
		}

		public String toString() {
			return "[x=" + a + ", y=" + b + "]";
		}

	}

	public static int[] sieve(int N) { // O(n*log(logn))
		int arr[] = new int[N + 1];
		for (int i = 2; i <= Math.sqrt(N); i++) {
			if (arr[i] == 0) {
				for (int j = i * i; j <= N; j = j + i) {
					arr[j] = 1;
				}
			}
		}
		return arr;
		// All the i for which arr[i]==0 are prime numbers.
	}

	static int gcd(int a, int b) { // O(logn)
		if (b == 0)
			return a;
		return gcd(b, a % b);
	}

	public static void debug(Object... o) {
		System.out.println(Arrays.deepToString(o));
	}

	static void catalan_numbers(int n) {
		long catalan[] = new long[n + 1];
		catalan[1] = 1;
		for (int i = 2; i <= n; i++) {
			for (int j = 1; j <= i - 1; j++) {
				catalan[i] = catalan[i] + ((catalan[j]) * catalan[i - j]);
			}
		}
	}

	static final class InputReader {
		private final InputStream stream;
		private final byte[] buf = new byte[1024];
		private int curChar;
		private int Chars;

		public InputReader(InputStream stream) {
			this.stream = stream;
		}

		private int read() throws IOException {
			if (curChar >= Chars) {
				curChar = 0;
				Chars = stream.read(buf);
				if (Chars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public final int nextInt() throws IOException {
			return (int) nextLong();
		}

		public final long nextLong() throws IOException {
			int c = read();
			while (isSpaceChar(c)) {
				c = read();
				if (c == -1)
					throw new IOException();
			}
			boolean negative = false;
			if (c == '-') {
				negative = true;
				c = read();
			}
			long res = 0;
			do {
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += (c - '0');
				c = read();
			} while (!isSpaceChar(c));
			return negative ? (-res) : (res);
		}

		public final int[] nextIntBrray(int size) throws IOException {
			int[] arr = new int[size];
			for (int i = 0; i < size; i++)
				arr[i] = nextInt();
			return arr;
		}

		public final String next() throws IOException {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.append((char) c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		public final String nextLine() throws IOException {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.append((char) c);
				c = read();
			} while (c != '\n' && c != -1);
			return res.toString();
		}

		private boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}
	}
}