Emuskald needs a fence around his farm, but he is too lazy to build it himself. So he purchased a fence-building robot.

He wants the fence to be a regular polygon. The robot builds the fence along a single path, but it can only make fence corners at a single angle a.

Will the robot be able to build the fence Emuskald wants? In other words, is there a regular polygon which angles are equal to a?

Input

The first line of input contains an integer t (0 < t < 180) — the number of tests. Each of the following t lines contains a single integer a (0 < a < 180) — the angle the robot can make corners at measured in degrees.

Output

For each test, output on a single line "YES" (without quotes), if the robot can build a fence Emuskald wants, and "NO" (without quotes), if it is impossible.

Examples

Input

3
30
60
90


Output

NO
YES
YES

Note

In the first test case, it is impossible to build the fence, since there is no regular polygon with angle <image>.

In the second test case, the fence is a regular triangle, and in the last test case — a square.
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) {
	InputStream inputStream = System.in;
	Scanner in = new Main().new Scanner(inputStream);
	Main solver = new Main();
	solver.solve(in);
    }

    public void solve(Scanner in) {
	int n = in.ni();
	for (int i = 0; i < n; i++) {
	    int t = in.ni();
	    if(t < 60) {
		System.out.println("NO");
	    } else if (360 % (180 - t) == 0){
		System.out.println("YES");
	    } else {
		System.out.println("NO");
	    }
	}
    }

    class Scanner {
	BufferedReader br;
	StringTokenizer in;

	public Scanner(InputStream inputStream) {
	    br = new BufferedReader(new InputStreamReader(inputStream));
	}

	public String next() {
	    return hasMoreTokens() ? in.nextToken() : null;
	}

	public String readLine() {
	    try {
		return br.readLine();
	    } catch (Exception e) {
		e.printStackTrace();
		return null;
	    }
	}

	boolean hasMoreTokens() {
	    while (in == null || !in.hasMoreTokens()) {
		String s = readLine();
		if (s == null)
		    return false;
		in = new StringTokenizer(s);
	    }
	    return true;
	}

	public String nextString() {
	    return next();
	}

	public int ni() {
	    return Integer.parseInt(nextString());
	}

	public long nl() {
	    return Long.parseLong(nextString());
	}

	public int[] nia(int n) {
	    int[] a = new int[n];
	    for (int i = 0; i < n; i++) {
		a[i] = ni();
	    }
	    return a;
	}

	public long[] nla(int n) {
	    long[] a = new long[n];
	    for (int i = 0; i < n; i++) {
		a[i] = ni();
	    }
	    return a;
	}
    }

    class Pair<T> implements Comparable<T> {
	T a;
	T b;

	public Pair(T c, T d) {
	    a = c;
	    b = d;
	}

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

	public int compareTo(T o) {
	    return a.toString().compareTo(b.toString());
	}

	@Override
	public boolean equals(Object obj) {
	    Pair<T> p2 = (Pair<T>) obj;
	    if (p2.a == a && p2.b == b)
		return true;
	    return false;
	}

    }
}
