output_description: If Takahashi can have exactly K black squares in the grid, print `Yes`;
  otherwise, print `No`.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N M K
attempt: import sys
  from sys import exit
  from collections import deque
  from bisect import (
      bisect_left,
      bisect_right,
      insort_left,
      insort_right,
  )  # func(リスト,値)
  from heapq import heapify, heappop, heappush
  from itertools import product, permutations, combinations, combinations_with_replacement
  from functools import reduce
  from math import sin, cos, tan, asin, acos, atan, degrees, radians
  
  sys.setrecursionlimit(10**6)
  INF = 10**20
  eps = 1.0e-20
  MOD = 10**9 + 7
  
  
  def lcm(x, y):
      return x * y // gcd(x, y)
  
  
  def lgcd(l):
      return reduce(gcd, l)
  
  
  def llcm(l):
      return reduce(lcm, l)
  
  
  def powmod(n, i, mod):
      return pow(n, mod - 1 + i, mod) if i < 0 else pow(n, i, mod)
  
  
  def div2(x):
      return x.bit_length()
  
  
  def div10(x):
      return len(str(x)) - (x == 0)
  
  
  def perm(n, mod=None):
      ans = 1
      for i in range(1, n + 1):
          ans *= i
          if mod != None:
              ans %= mod
      return ans
  
  
  def intput():
      return int(input())
  
  
  def mint():
      return map(int, input().split())
  
  
  def lint():
      return list(map(int, input().split()))
  
  
  def ilint():
      return int(input()), list(map(int, input().split()))
  
  
  def judge(x, l=["Yes", "No"]):
      print(l[0] if x else l[1])
  
  
  def lprint(l, sep="\n"):
      for x in l:
          print(x, end=sep)
  
  
  def ston(c, c0="a"):
      return ord(c) - ord(c0)
  
  
  def ntos(x, c0="a"):
      return chr(x + ord(c0))
  
  
  class counter(dict):
      def __init__(self, *args):
          super().__init__(args)
  
      def add(self, x, d=1):
          self.setdefault(x, 0)
          self[x] += d
  
  
  class comb:
      def __init__(self, n, mod=None):
          self.l = [1]
          self.n = n
          self.mod = mod
  
      def get(self, k):
          l, n, mod = self.l, self.n, self.mod
          k = n - k if k > n // 2 else k
          while len(l) <= k:
              i = len(l)
              l.append(
                  l[i - 1] * (n + 1 - i) // i
                  if mod == None
                  else (l[i - 1] * (n + 1 - i) * powmod(i, -1, mod)) % mod
              )
          return l[k]
  
  
  N, M, K = mint()
  ans = False
  for i in range(N + 1):
      for j in range(M + 1):
          if i * (M - j) + (N - i) * j == K:
              ans = True
              break
  judge(ans)
  
problem_description: Statement
  
  We have a grid with N rows and M columns of squares. Initially, all the
  squares are white.
  
  There is a button attached to each row and each column. When a button attached
  to a row is pressed, the colors of all the squares in that row are inverted;
  that is, white squares become black and vice versa. When a button attached to
  a column is pressed, the colors of all the squares in that column are
  inverted.
  
  Takahashi can freely press the buttons any number of times. Determine whether
  he can have exactly K black squares in the grid.
samples: [{"input": "2 2 2", "output": "Yes\n    \n\nPress the buttons in the order of the first row, the first column.\n\n* * *"}, {"input": "2 2 1", "output": "No\n    \n\n* * *"}, {"input": "3 5 8", "output": "Yes\n    \n\nPress the buttons in the order of the first column, third column, second row,\nfifth column.\n\n* * *"}, {"input": "7 9 20", "output": "No"}]