description: 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.
solution: import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.util.*;
  import java.util.stream.Collectors;
  
  import static java.lang.Math.max;
  import static java.lang.System.currentTimeMillis;
  import static java.lang.System.out;
  import static java.util.Arrays.sort;
  import static java.util.Collections.reverseOrder;
  
  public class A {
      public static final boolean LOCAL = System.getProperty("ONLINE_JUDGE") == null;
      // public static final boolean LOCAL = System.getProperty("LOCAL")!=null;
      public static final String ANSI_RED = "\u001B[31m";
      public static final String ANSI_RESET = "\u001B[0m";
      static final int M = (int) 1e9 + 7;
      static final long MM = (long) M * M;
      static final int MAX = Integer.MAX_VALUE;
      static final int MIN = Integer.MIN_VALUE;
      static final int SIZE = (int) 1e9 * 2;
      static ArrayList<Integer> primes = new ArrayList<>();
      //static Scanner sc = new Scanner(System.in);
      static FastReader sc = new FastReader();
      static long startTime;
      static long endTime;
      static boolean[] prime;
      static int[] visited;
      static ArrayList<ArrayList<Integer>> graph;
      static ArrayList<Integer> topologicalSort;
      static boolean isCyclic = false;
  
      public static int swap(int... args) {
          return args[0];
      }
  
      public static void main(String[] args) throws IOException {
          do {
              startTime = currentTimeMillis();
              //setOut(new PrintStream("output"));
              //setIn(new FileInputStream("input"));
              int T = sc.nextInt();
              while (T-- != 0) {
                  solve();
  
              }
              endTime = currentTimeMillis();
              long duration = endTime - startTime;
              //out.println(duration);
              if (false) {
                  out.println(max(3, 2));
                  Integer[] ARRAY = new Integer[2];
                  ArrayList<Integer> LIST = new ArrayList<>();
                  LIST.add(2);
                  // sort(LIST, reverseOrder());
                  LIST.sort(reverseOrder());
                  sort(ARRAY, reverseOrder());
                  out.println(LIST + " " + Arrays.toString(ARRAY));
              }
          } while (LOCAL);
      }
  
      public static void solve() throws IOException {
  /////////////////////////////////////////////////////////////////////
         long a =sc.nextLong(),b=sc.nextLong(),c=sc.nextLong();
          out.println((a+2*b+3*c)%2);
  
  ///////////////////////////////////////////////////////////////////////
  
      }
  
      static void dfs(int src) {
          visited[src] = 1;
          for (Integer integer : graph.get(src)) {
              if (visited[integer] != 1) {
                  dfs(integer);
              }
          }
          topologicalSort.add(src);
  
      }
  
      static void detectCycle(int src) {
          visited[src] = 2;
          for (Integer integer : graph.get(src)) {
              if (visited[integer] == 0) {
                  detectCycle(integer);
              } else if (visited[integer] == 2) {
                  isCyclic = true;
                  return;
              }
  
          }
          visited[src] = 1;
      }
  
      static <Array, Target> int count(Array[] array, Target target) {
          int cn = 0;
          for (Array value : array) {
              if (value.equals(target)) cn++;
          }
          return cn;
      }
  
      static int count(String string, char target) {
          int cn = 0;
          for (int i = 0; i < string.length(); i++) {
              if (string.charAt(i) == target) cn++;
          }
          return cn;
      }
  
      static <Array> void revArray(Array[] arr) {
          int n = arr.length;
          for (int i = 0; i < n / 2; i++) {
              Array temp = arr[i];
              arr[i] = arr[n - i - 1];
              arr[n - i - 1] = temp;
          }
  
      }
  
      static <Array> void printArray(Array[] arr) {
          int n = arr.length;
          for (Array array : arr) out.print(array + " ");
          out.println();
      }
  
      static void yes() {
          out.println("YES");
      }
  
      static void no() {
          out.println("NO");
      }
  
      public static boolean isPal(String s) {
          StringBuilder stringBuilder = new StringBuilder(s);
          return s.equals(stringBuilder.reverse().toString());
      }
  
      public static int lowerBound(Integer[] array, int length, int value) {
          int low = -1;
          int hi = length;
          while (low + 1 < hi) {
              int mid = (low + hi) / 2;
              if (array[mid] <= value) {
                  low = mid;
              } else {
                  hi = mid;
              }
          }
          return low;
      }
  
      public static int upperBound(Integer[] array, int length, int value) {
          int low = -1;
          int hi = length;
          while (low + 1 < hi) {
              int mid = (low + hi) >> 1;
              if (array[mid] >= value) {
                  hi = mid;
              } else low = mid;
          }
          return hi;
      }
  
      public static int binarySearch(Integer[] arr, int length, int value) {
          int low = 0;
          int hi = length - 1;
          int ans = -1;
          while (low <= hi) {
              int mid = (low + hi) >> 1;
              if (arr[mid] > value) {
                  hi = mid - 1;
              } else if (arr[mid] < value) {
                  low = mid + 1;
              } else {
                  ans = mid;
                  break;
              }
          }
          return ans;
      }
  
      public static int gcd(int a, int b) {
          return b == 0 ? a : gcd(b, a % b);
      }
  
      public static int lcm(int a, int b) {
          return a / gcd(a, b) * b;
      }
  
      public static int countDivs(int n) {
          int cn = 0;
          int sqr = (int) Math.sqrt(n);
          for (int i = 1; i <= sqr; ++i) {
              if (n % i == 0) {
                  ++cn;
              }
          }
          cn *= 2;
          if (sqr * sqr == n) cn--;
          return cn;
      }
  
      static void prime(int x) {
          //sieve algorithm. nlog(log(n)).
          prime = new boolean[(x + 1)];
          Arrays.fill(prime, true);
          prime[0] = prime[1] = false;
          for (int i = 2; i * i <= x; i++)
              if (prime[i])
                  for (int j = i * i; j <= x; j += i)
                      prime[j] = false;
      }
  
      static boolean isEven(long x) {
          return x % 2 == 0;
      }
  
      static boolean isPrime(long x) {
          boolean flag = true;
          int sqr = (int) Math.sqrt(x);
          if (x < 2) return false;
          for (int i = 2; i <= sqr; i++) {
              if (x % i == 0) {
                  flag = false;
                  break;
              }
          }
          return flag;
      }
  
      static long factorial(long x) {
          long total = 1;
          for (int i = 3; i <= x; i++)
              total = (total * i) % M;
          return total;
      }
  
      static long power(long x, long n) {
          if (n == 0) {
              return 1;
          }
          long pow = power(x, n / 2L);
          if ((n & 1) == 1) {
              return (x * (pow) * (pow));
          }
          return (pow * pow);
      }
  
      private static <T> String ts(T t) {
          if (t == null) {
              return "null";
          }
          try {
              return ts((Iterable) t);
          } catch (ClassCastException e) {
              if (t instanceof int[]) {
                  String s = Arrays.toString((int[]) t);
                  return "{" + s.substring(1, s.length() - 1) + "}";
              } else if (t instanceof long[]) {
                  String s = Arrays.toString((long[]) t);
                  return "{" + s.substring(1, s.length() - 1) + "}";
              } else if (t instanceof char[]) {
                  String s = Arrays.toString((char[]) t);
                  return "{" + s.substring(1, s.length() - 1) + "}";
              } else if (t instanceof double[]) {
                  String s = Arrays.toString((double[]) t);
                  return "{" + s.substring(1, s.length() - 1) + "}";
              } else if (t instanceof boolean[]) {
                  String s = Arrays.toString((boolean[]) t);
                  return "{" + s.substring(1, s.length() - 1) + "}";
              }
              try {
                  return ts((Object[]) t);
              } catch (ClassCastException e1) {
                  return t.toString();
              }
          }
      }
  
      private static <T> String ts(T[] arr) {
          StringBuilder ret = new StringBuilder();
          ret.append("{");
          boolean first = true;
          for (T t : arr) {
              if (!first) {
                  ret.append(", ");
              }
              first = false;
              ret.append(ts(t));
          }
          ret.append("}");
          return ret.toString();
      }
  
      private static <T> String ts(Iterable<T> iter) {
          StringBuilder ret = new StringBuilder();
          ret.append("{");
          boolean first = true;
          for (T t : iter) {
              if (!first) {
                  ret.append(", ");
              }
              first = false;
              ret.append(ts(t));
          }
          ret.append("}");
          return ret.toString();
      }
  
      public static void dbg(Object... o) {
          if (LOCAL) {
              System.err.print("Line #" + Thread.currentThread().getStackTrace()[2].getLineNumber() + ": [");
              for (int i = 0; i < o.length; i++) {
                  if (i != 0) {
                      System.err.print(", ");
                  }
                  System.err.print(ts(o[i]));
              }
              System.err.println("]");
          }
      }
  
      static class FastReader {
          BufferedReader br;
          StringTokenizer st;
  
          public FastReader() {
              br = new BufferedReader(new
                      InputStreamReader(System.in));
          }
  
          String next() {
              while (st == null || !st.hasMoreElements()) {
                  try {
                      st = new StringTokenizer(br.readLine());
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              return st.nextToken();
          }
  
          int nextInt() {
              return Integer.parseInt(next());
          }
  
          long nextLong() {
              return Long.parseLong(next());
          }
  
          double nextDouble() {
              return Double.parseDouble(next());
          }
  
          String nextLine() {
              String str = "";
              try {
                  str = br.readLine();
              } catch (IOException e) {
                  e.printStackTrace();
              }
              return str;
          }
      }
  
      static class Pair implements Comparable<Pair> {
          private final int key;
          private final int value;
  
          public Pair(int key, int value) {
              this.key = key;
              this.value = value;
          }
  
          public int second() {
              return value;
          }
  
          @Override
          public int compareTo(Pair o) {
              int val = -Integer.compare(value, o.value);
              if (val == 0) {
                  return -Integer.compare(key, o.key);
              }
              return val;
          }
  
          @Override
          public String toString() {
              return "Pair{" + "x=" + key + ", y=" + value + '}';
          }
      }
  
  }
  