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 java.io.*;
  import java.util.*;
  import java.lang.Math;
  
  public class Main{
  	static BufferedReader reader;
  	static StringTokenizer tokenizer;
  	static PrintWriter writer;
  
  	static int nextInt() throws IOException {
  		return Integer.parseInt(nextToken());
  	}
  
  	static long nextLong() throws IOException {
  		return Long.parseLong(nextToken());
  	}
  
  	static double nextDouble() throws IOException {
  		return Double.parseDouble(nextToken());
  	}
  
  	static String nextToken() throws IOException {
  		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
  			tokenizer = new StringTokenizer(reader.readLine());
  		}
  		return tokenizer.nextToken();
  	}
  	static String nexts() throws IOException {
  	  	  tokenizer = new StringTokenizer(reader.readLine());
  	   	 String s="";
  	   	 while (tokenizer.hasMoreTokens()) {
  			s+=tokenizer.nextElement()+" ";
  		}
  		return s;
  	}
  	public static int gcd(int x, int y){
  		if (y == 0) return x; else return gcd(y, x % y);
  	}
  	public static long gcd(long x, long y){
  		if (y == 0) return x; else return gcd(y, x % y);
  	}
      static long digitSum(String x) {
  		long a = 0;
  		for (int i = 0; i < x.length(); i++) {
  			a += x.charAt(i) - '0';
  		}
  		return a;
  	}
  
  	static long digitSum(long x) {
  		long a = 0;
  		while (x > 0) {
  			a += x % 10;
  			x /= 10;
  		}
  		return a;
  	}
  static int max(int x, int y) {
  		return Math.max(x, y);
  	}
  	static int min(int x, int y) {
  		return Math.min(x, y);
  	}
  	static int max(int x, int y, int z) {
  		x = Math.max(x, y);
  		x = Math.max(x, z);
  		return x;
  	}
  	static int min(int x, int y, int z) {
  		x = Math.min(x, y);
  		x = Math.min(x, z);
  		return x;
  	}
  	static long max(long x, long y) {
  		return Math.max(x, y);
  	}
  	static long min(long x, long y) {
  		return Math.min(x, y);
  	}
  	static long max(long x, long y, long z) {
  		x = Math.max(x, y);
  		x = Math.max(x, z);
  		return x;
  	}
  	static long min(long x, long y, long z) {
  		x = Math.min(x, y);
  		x = Math.min(x, z);
  		return x;
  	}
  	static double max(double x, double y) {
  		return Math.max(x, y);
  	}
  	static double min(double x, double y) {
  		return Math.min(x, y);
  	}
  	static double max(double x, double y, double z) {
  		x = Math.max(x, y);
  		x = Math.max(x, z);
  		return x;
  	}
  	static double min(double x, double y, double z) {
  		x = Math.min(x, y);
  		x = Math.min(x, z);
  		return x;
  	}
      static void rsort(int[] ar) {
  		Arrays.sort(ar);
  		int len = ar.length;
  		for (int i = 0; i < len / 2; i++) {
  			int tmp = ar[i];
  			ar[i] = ar[len - 1 - i];
  			ar[len - 1 - i] = tmp;
  		}
  	}
  	static void rsort(long[] ar) {
  		Arrays.sort(ar);
  		int len = ar.length;
  		for (int i = 0; i < len / 2; i++) {
  			long tmp = ar[i];
  			ar[i] = ar[len - 1 - i];
  			ar[len - 1 - i] = tmp;
  		}
  	}
  	static void rsort(double[] ar) {
  		Arrays.sort(ar);
  		int len = ar.length;
  		for (int i = 0; i < len / 2; i++) {
  			double tmp = ar[i];
  			ar[i] = ar[len - 1 - i];
  			ar[len - 1 - i] = tmp;
  		}
  	}
  	static void rsort(char[] ar) {
  		Arrays.sort(ar);
  		int len = ar.length;
  		for (int i = 0; i < len / 2; i++) {
  			char tmp = ar[i];
  			ar[i] = ar[len - 1 - i];
  			ar[len - 1 - i] = tmp;
  		}
  	}
      static long lcm(long a, long b) throws IOException {
  		return a * b / gcd(a, b);
  	}
      static int lcm(int a, int b) throws IOException {
  		return a * b / gcd(a, b);
  	}
      static int rev(int x) {
  		int a = 0;
  		while (x > 0) {
  			a = a * 10 + x % 10;
  			x /= 10;
  		}
  		return a;
  	}
  	public static boolean isPrime(int nn) 
  	    { 
  	         if(nn<=1)return false;
  		  if(nn<=3){return true; }
  		 if (nn%2==0||nn%3==0){return false; }
  		 for (int i=5;i*i<=nn;i=i+6){ 
  	            if(nn%i==0||nn%(i+2)==0){return false;  }}
  	         return true; 
  	    } 
  public static void shuffle(int[] A) {
  		for (int i = 0; i < A.length; i++) {
  			int j = (int)(i * Math.random());
  			int tmp = A[i];A[i] = A[j];A[j] = tmp;
  		}
  	}
  	public static void shufflel(Long[] A) {
  		for (int i = 0; i < A.length; i++) {
  			int j = (int)(i * Math.random());
  			long tmp = A[i];A[i] = A[j];A[j] = tmp;
  		}
  	}
  
  	public static String reverse(String input)
   	   {
  	        StringBuilder input2=new StringBuilder();
  	        input2.append(input);
  	        input2 = input2.reverse();
  	        return input2.toString();
  	    }
      public static long power(int x, long n)
  	{
  	//    long mod = 1000000007;
  		if (n == 0) {
  			return 1;
  		}
          long pow = power(x, n / 2);
  
  		if ((n & 1) == 1) {
  			return (x * pow * pow);
  		}
  		return (pow * pow);
  	}
  	public static long power(long x, long y, long p)     //x^y%p
  	    { 
    	       long res = 1; 
  	       x = x % p; 
    	       while (y > 0) { 
   	 	 if (y % 2 == 1) {
        	        	        res = (res * x) % p; 
  		 }
    		 y = y >> 1; // y = y/2 
       	     	 x = (x * x) % p; 
       	         } 
    	         return res; 
      	} 
  
  	 static long ncr(int n, int k)  
     	 { 
             		 long res = 1; 
    		   // Since C(n, k) = C(n, n-k)  
   		       if (k > n - k) { 
       		       k = n - k; 
        		  } 
    		  // Calculate value of [n*(n-1)*---*(n-k+1)] / [k*(k-1)*---*1]  
       		   for (int i = 0; i < k; ++i) { 
          		    res *= (n - i); 
           		   res /= (i + 1); 
       		   } 
    		  return res; 
   	   }
  	public static int inv(int a, int m)     //Returns modulo inverse of a with respect to m using extended euclid algorithm
  	    { 
  	        int m0=m,t,q; 
  	        int x0=0,x1=1; 
        	        if(m==1){
  	                return 0; }
                   	         while(a>1) 
       	        {  
     	                q=a/m; 
      	                t=m; 
                                   m=a%m;a=t; 
      	                t=x0; 
       	                x0=x1-q*x0; 
        	                x1=t; } 
      	          if(x1<0){
   	   	 x1+=m0; }
     	           return x1; 
  	    } 
  
  	static int modInverse(int n, int p) 
    	{ 
      	          return (int)power((long)n, (long)(p - 2),(long)p); 
  	 } 
  	static int ncrmod(int n, int r, int p) 
     	 { 
  	        if (r == 0)        // Base case 
  	            return 1; 
    	        int[] fac = new int[n + 1];         // Fill factorial array so that we can find all factorial of r, n and n-r 
  	        fac[0] = 1; 
  	        for (int i = 1; i <= n; i++) 
                                       fac[i] = fac[i - 1] * i % p; 
     	         return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) % p;     //IMPORTANT
      	}	 
  
  	static int upper(int a[], int x)   //Returns rightest index of x in sorted arr else -1
    	  {                                                //If not present returns index of just smaller element
    	            int n=a.length;
      	        int l=0;
                  int r=n-1;
                  int ans=-1;
                  while(l<=r){
                      int m=(r-l)/2+l;
                      if(a[m]<=x){
                          ans=m;
                          l=m+1;
                      }
                      else{
                          r=m-1;
                      }
                  }
                   return ans;  
                  } 
  	static int lower(int a[], int x)     //Returns leftest index of x in sorted arr else n
   	   {                                                  //If not present returns index of just greater element
   	            int n=a.length;
     	            int l=0;
                  int r=n-1;
                  int ans=n;
                  while(l<=r){
                      int m=(r-l)/2+l;
                      if(a[m]>=x){
                          ans=m;
                          r=m-1;
                      }
                      else{
                           l=m+1;
                      }
                  }
                   return ans; 
                   } 
  
  	public static long stringtoint(String s){ // Convert bit string to number
  		long a = 1;
  		long ans = 0;
  		StringBuilder sb = new StringBuilder();
  		sb.append(s);  
  		sb.reverse();
  		s=sb.toString();
  		for(int i=0;i<s.length();i++){
  			ans = ans + a*(s.charAt(i)-'0');
  			a = a*2;
  		}
  		return ans;
  	}
   
  	String inttostring(long a,long m){        // a is number and m is length of string required
  		String res = "";                     // Convert a number in bit string representation
  		for(int i=0;i<(int)m;i++){
  			if((a&(1<<i))==1){
  				res+='1';
  			}else
  				res+='0';
  		}
  		StringBuilder sb = new StringBuilder();
  		sb.append(res);  
  		sb.reverse();
  		res=sb.toString();
  		return res;
      }
      static final int inf = Integer.MAX_VALUE / 2;
  	static final long linf = Long.MAX_VALUE / 3;
  	static final long mod = (long) 1e9 + 7;
      
  	
  	 static class R implements Comparable<R>{
  	        int x, y;
  	        public  R(int x, int y) {           //a[i]=new R(x,y);
  	            this.x = x;
  	            this.y = y;
  	        }
  	        public int compareTo(R o) {
              		return x-o.x;     //Increasing order(Which is usually required)
          		}
  	    }   
  
  //Check if palindrome string - System.out.print(A.equals(new StringBuilder(A).reverse().toString())?"Yes":"No");
  	public static void main(String[] args) throws IOException {
  		reader = new BufferedReader(new InputStreamReader(System.in));
  		tokenizer = null;
  		writer = new PrintWriter(System.out);
  		solve();
  		reader.close();
  		writer.close();
  	}
  	//public static boolean check() {
  //
  //	}
  	private static void solve() throws IOException {
  		int t = nextInt();
  		while(t-->0){
  			//String s= nextToken();
  			//String[] s = str.split("\\s+");
  			//ArrayList<Integer> ar=new ArrayList<Integer>();
  			//HashSet<Integer> set=new HashSet<Integer>();
  			//HashMap<Integer,String> h=new HashMap<Integer,String>();
  			//R[] a1=new R[n];
  			//char[] c=nextToken().toCharArray();
  			//PriorityQueue<Integer> pq=new PriorityQueue<Integer>(Collections.reverseOrder());
  			//NavigableSet<Integer> pq=new TreeSet<>();
  			int n = nextInt();
  			int m = nextInt();
  			int k = nextInt();
  			//long n = nextLong();
  			
  			
  			//shuffle(a);
  			//shufflel(a);rsort();
  			//Arrays.sort(a);
  			//StringBuilder ans=new StringBuilder();
  			if(n%2==0){
  			    int max=n*(m/2);
                  int min=0;
                  if(k>=min&&k<=max&&k%2==0){
                      writer.println("YES");
                  }
                  else writer.println("NO");
  			}
              else{
                  int max=n*(m/2);
                  int min=m/2;
                  int kk=k;
                  kk-=min;
                  if(k>=min&&k<=max&&kk%2==0){
                      writer.println("YES");
                  }
                  else writer.println("NO");
              }
              
  			
  		 }
  	}
  }