description: The only difference between this problem and D2 is that you don't have to provide the way to construct the answer in this problem, but you have to do it in D2.
  
  There's a table of n × m cells (n rows and m columns). The value of n ⋅ m is even.
  
  A domino is a figure that consists of two cells having a common side. It may be horizontal (one of the cells is to the right of the other) or vertical (one of the cells is above the other).
  
  You need to find out whether it is possible to place nm/2 dominoes on the table so that exactly k of them are horizontal and all the other dominoes are vertical. The dominoes cannot overlap and must fill the whole table.
  
  Input
  
  The first line contains one integer t (1 ≤ t ≤ 10) — the number of test cases. Then t test cases follow.
  
  Each test case consists of a single line. The line contains three integers n, m, k (1 ≤ n,m ≤ 100, 0 ≤ k ≤ nm/2, n ⋅ m is even) — the number of rows, columns and horizontal dominoes, respectively.
  
  Output
  
  For each test case output "YES", if it is possible to place dominoes in the desired way, or "NO" otherwise.
  
  You may print each letter in any case (YES, yes, Yes will all be recognized as positive answer, NO, no and nO will all be recognized as negative answer).
  
  Example
  
  Input
  
  
  8
  4 4 2
  2 3 0
  3 2 3
  1 2 0
  2 4 2
  5 2 2
  2 17 16
  2 1 1
  
  
  Output
  
  
  YES
  YES
  YES
  NO
  YES
  NO
  YES
  NO
solution: import static java.lang.Math.max;
  import static java.lang.Math.min;
  import static java.lang.Math.abs;
  import java.util.*;
  import java.io.*;
  
  public class A
  {
      static int n, m, k;
      static int[] arr;
      static char[] s;
      public static void main(String[] args) throws IOException
      {
          f = new Flash();
          out = new PrintWriter(System.out);
          
          int T = ni();
          for(int tc = 1; tc <= T; tc++){
          	n = ni(); m = ni(); k = ni(); sop(fn());
          }
          
          out.flush(); out.close();
      }
      
      static String fn()
      {
          if(n%2 == 0 && m%2 == 0) {
          	if(k%2 == 0) return yes;
          	return no;
          }
          
          if(n%2 == 0) {
          	if(k <= n*(m-1)/2) {
          		if(k%2 == 0) return yes;
              	return no;
          	}
          	
          	return no;
          }
          
          if(m%2 == 0) {
          	k -= m/2;
          	if(k < 0) return no;
          	if(k%2 == 0) return yes;
          	return no;
          }
          
          return no;
      }
      
      static Flash f;
      static PrintWriter out;
      static final long mod = (long)1e9+7;
      static final long inf = (long)1e18;
      static final int _inf = (int)1e9;
      static final int maxN = (int)1e6;
      static long[] fact, inv;
      
      static class cpr implements Comparator<int[]>{
      	public int compare(int[] a, int[] b) {
      		return Integer.compare(a[0], b[0]);
      	}
      }
      
      static void sort(int[] a){
          List<Integer> A = new ArrayList<>();
          for(int i : a) A.add(i);
          Collections.sort(A);
          for(int i = 0; i < A.size(); i++) a[i] = A.get(i);
      }
      
      static void sort(long[] a){
          List<Long> A = new ArrayList<>();
          for(long i : a) A.add(i);
          Collections.sort(A);
          for(int i = 0; i < A.size(); i++) a[i] = A.get(i);
      }
      
      static void print(int[] a){
          StringBuilder sb = new StringBuilder();
          for(int i = 0; i < a.length; i++) sb.append(a[i] + " ");
          sop(sb);
      }
      
      static void print(long[] a){
          StringBuilder sb = new StringBuilder();
          for(int i = 0; i < a.length; i++) sb.append(a[i] + " ");
          sop(sb);
      }
      
      static int swap(int itself, int dummy){return itself;}
      static long swap(long itself, long dummy){return itself;}
      static char swap(char itself, char dummy){return itself;}
      static void sop(Object o){out.println(o);}
      static int ni(){return f.ni();}
      static long nl(){return f.nl();}
      static double nd(){return f.nd();}
      static String next(){return f.next();}
      static String ns(){return f.ns();}
      static String yes = "YES", no = "NO";
      static char[] nc(){return f.nc();}
      static int[] arr(int len){return f.arr(len);}
      static int gcd(int a, int b){if(b == 0) return a; return gcd(b, a%b);}
      static long gcd(long a, long b){if(b == 0) return a; return gcd(b, a%b);}
      static int fcm(int a, int b){return (a*b)/gcd(a, b);}
      static long fcm(long a, long b){return (a*b)/gcd(a, b);}
      static double log2(long N) {return Math.log(N) / Math.log(2);}
      static void debug(int[] a) {sop(Arrays.toString(a));}
      static void debug(long[] a) {sop(Arrays.toString(a));}
      
      static class Flash
      {
          BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
          StringTokenizer st = new StringTokenizer("");
          
          String next(){
              while(!st.hasMoreTokens()){
                  try{
                      st = new StringTokenizer(br.readLine());
                  }catch(IOException e){
                      e.printStackTrace();
                  }
              }
              
              return st.nextToken();
          }
          
          String ns(){
              String s = new String();
              try{
                  s = br.readLine().trim();
              }catch(IOException e){
                  e.printStackTrace();
              }
              
              return s;
          }
          
          int[] arr(int n){
              int[] a = new int[n];
              for(int i = 0; i < n; i++) a[i] = ni();
              return a;
          }
          
          char[] nc(){return ns().toCharArray();}
          int ni(){return Integer.parseInt(next());}
          long nl(){return Long.parseLong(next());}
          double nd(){return Double.parseDouble(next());}
      }
  }