Luntik has decided to try singing. He has a one-minute songs, b two-minute songs and c three-minute songs. He wants to distribute all songs into two concerts such that every song should be included to exactly one concert.

He wants to make the absolute difference of durations of the concerts as small as possible. The duration of the concert is the sum of durations of all songs in that concert.

Please help Luntik and find the minimal possible difference in minutes between the concerts durations.

Input

The first line contains a single integer t (1 ≤ t ≤ 1000) — the number of test cases.

Each test case consists of one line containing three integers a, b, c (1 ≤ a, b, c ≤ 10^9) — the number of one-minute, two-minute and three-minute songs.

Output

For each test case print the minimal possible difference in minutes between the concerts durations.

Example

Input


4
1 1 1
2 1 3
5 5 5
1 1 2


Output


0
1
0
1

Note

In the first test case, Luntik can include a one-minute song and a two-minute song into the first concert, and a three-minute song into the second concert. Then the difference will be equal to 0.

In the second test case, Luntik can include two one-minute songs and a two-minute song and a three-minute song into the first concert, and two three-minute songs into the second concert. The duration of the first concert will be 1 + 1 + 2 + 3 = 7, the duration of the second concert will be 6. The difference of them is |7-6| = 1.
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Collections;
import java.util.StringTokenizer;

public class Solve {

	static long MOD = 998244353L;
	static long INF = 1000_000_000_000_000L + 100;
	static boolean isPrime[];

	public static void main(String[] args) throws Exception {
		Scanner sc = new Scanner();
		PrintWriter pw = new PrintWriter(System.out);

		int t = sc.nextInt();
		while (t-- > 0) {
			long a = sc.nextLong();
			long b = sc.nextLong();
			long c = sc.nextLong();
			long sum = a + b * 2 + 3 * c;

			pw.println(sum % 2);

		}
		pw.flush();

	}

	static int LowerBound(int a[], int x, int start) { // x is the target value or key
		int ans = -1;

		int l = start, r = a.length;
		while (l + 1 < r) {
			System.out.println("lolk");

			int m = (l + r) >>> 1;
			if (a[m] >= x) {
				ans = m;
				r = m;
			} else
				l = m;
		}
		return ans;
	}

	static int UpperBound(int a[], int x, int start) {// x is the key or target value
		int ans = -1;

		int l = start, r = a.length;
		while (l + 1 < r) {
			int m = (l + r) >>> 1;
			if (a[m] <= x) {
				ans = m;
				l = m;
			} else
				r = m;
		}
		return ans;
	}

	static public boolean[] sieve(int n) {
		boolean prime[] = new boolean[n + 1];
		for (int i = 0; i <= n; i++)
			prime[i] = true;

		for (int p = 2; p * p <= n; p++) {
			// If prime[p] is not changed, then it is a
			// prime
			if (prime[p] == true) {
				// Update all multiples of p
				for (int i = p * p; i <= n; i += p)
					prime[i] = false;
			}
		}
		return prime;

	}

	public static ArrayList<Integer> primeFactors(int n) {
		ArrayList<Integer> set = new ArrayList<Integer>();

		// Print the number of 2s that divide n
		while (n % 2 == 0) {
			n /= 2;
			set.add(2);
		}

		// n must be odd at this point. So we can
		// skip one element (Note i = i +2)
		for (int i = 3; i * i <= n; i += 2) {
			// While i divides n, print i and divide n
			while (n % i == 0) {
				n /= i;
				set.add(i);
			}
		}

		if (n > 1)
			set.add(n);

		return set;

	}

	static int gcd(int a, int b) {
		if (a == 0)
			return b;
		if (b == 0)
			return a;

		return gcd(b, a % b);

	}

	public static int[] swap(int data[], int left, int right) {

		// Swap the data
		int temp = data[left];
		data[left] = data[right];
		data[right] = temp;

		// Return the updated array
		return data;
	}

	public static long[] euclidExtended(long a, long b) {
		if (b == 0) {
			long ar[] = new long[] { 1, 0 };
			return ar;
		}
		long ar[] = euclidExtended(b, a % b);
		long temp = ar[0];
		ar[0] = ar[1];
		ar[1] = temp - (a / b) * ar[1];
		return ar;
	}

	public static long modInverse(long a, long m) {
		long ar[] = euclidExtended(a, m);
		return ((ar[0] % m) + m) % m;
	}

	// Fermat Theorem
	public static long ncr(int n, int r, long[] fact) {
		if (n == r)
			return 1;
		if (r == 1)
			return n;
		if (n == 0 || r == 0)
			return 1;
		return (fact[n] * modInverse(((long) fact[n - r]) * fact[r], MOD)) % MOD;
	}

	static void sort(int[] a) {
		ArrayList<Integer> l = new ArrayList<>();
		for (int i : a)
			l.add(i);
		Collections.sort(l);
		for (int i = 0; i < a.length; i++)
			a[i] = l.get(i);
	}

}

class Pair {
	int x, y;

	Pair(int x, int y) {
		this.x = x;
		this.y = y;
	}

}

class SegTree {
	int leftmost, rightmost, sum;
	SegTree lChild, rChild;

	public SegTree(int leftmost, int rightmost) {
		this.leftmost = leftmost;
		this.rightmost = rightmost;
	}

	public void update(int index, int val) {
		sum++;
		if (leftmost == rightmost) {
			return;
		}
		if (lChild == null)
			makeKids();
		if (index <= lChild.rightmost)
			lChild.update(index, val);
		else
			rChild.update(index, val);
	}

	public void makeKids() {
		int mid = (leftmost + rightmost) / 2;
		lChild = new SegTree(leftmost, mid);
		rChild = new SegTree(mid + 1, rightmost);
	}

	public int query(int l, int r) {
		if (l <= leftmost && r >= rightmost)
			return sum;
		if (l > rightmost || r < leftmost)
			return 0;
		if (lChild == null)
			return 0;
		return lChild.query(l, r) + rChild.query(l, r);
	}
}

class UnionFind {
	int[] p, rank, setSize;
	int numSets;

	public UnionFind(int N) {
		p = new int[numSets = N];
		rank = new int[N];
		setSize = new int[N];
		for (int i = 0; i < N; i++) {
			p[i] = i;
			setSize[i] = 1;
		}
	}

	public int findSet(int i) {
		return p[i] == i ? i : (p[i] = findSet(p[i]));
	}

	public boolean isSameSet(int i, int j) {
		return findSet(i) == findSet(j);
	}

	public void unionSet(int i, int j) {
		if (isSameSet(i, j))
			return;
		numSets--;
		int x = findSet(i), y = findSet(j);
		if (rank[x] > rank[y]) {
			p[y] = x;
			setSize[x] += setSize[y];
		} else {
			p[x] = y;
			setSize[y] += setSize[x];
			if (rank[x] == rank[y])
				rank[y]++;
		}
	}

	public int numDisjointSets() {
		return numSets;
	}

	public int sizeOfSet(int i) {
		return setSize[findSet(i)];
	}
}

class Scanner {
	BufferedReader br;
	StringTokenizer st;

	Scanner() {
		br = new BufferedReader(new InputStreamReader(System.in));
	}

	String next() throws IOException {
		while (st == null || !st.hasMoreElements())
			st = new StringTokenizer(br.readLine());
		return st.nextToken();
	}

	int nextInt() throws NumberFormatException, IOException {
		return Integer.parseInt(next());
	}

	int[] nextIntArray(int n) throws NumberFormatException, IOException {
		int a[] = new int[n];
		for (int i = 0; i < n; i++)
			a[i] = Integer.parseInt(next());
		return a;
	}

	long nextLong() throws NumberFormatException, IOException {
		return Long.parseLong(next());
	}

	long[] nextLongArray(int n) throws NumberFormatException, IOException {
		long a[] = new long[n];
		for (int i = 0; i < n; i++)
			a[i] = Long.parseLong(next());
		return a;
	}

	double nextDouble() throws NumberFormatException, IOException {
		return Double.parseDouble(next());
	}
}