/*If you are full of hope,you will be invincible.*/
#include <bits/stdc++.h>
typedef long long ll ;
typedef unsigned long long u64 ;  
std::mt19937 rnd(time(nullptr)+(unsigned long long)(new char)+20051107);
namespace hpy {
    constexpr int HL = 1<<20 ;
    char buf[HL],buff[HL],*t1 = buf,*t2 = buf,*T = buff;
    
    inline char getc() {
        #ifndef feicheng
            return (t1 == t2 && (t2 = (t1 = buf) + fread(buf,1,HL,stdin),t1 == t2)?EOF:*t1++) ;
        #else
            return getchar();
        #endif
    }
    
    inline void flush() {
        fwrite(buff,1,T-buff,stdout),T = buff;
    }
    
    inline void putc(const char ch) {
        if(T == buff + HL) flush() ;
        *T ++ = ch;
    }

    struct Read {
        template <typename Tp>
        inline Read& operator >>  (Tp &x) {
            char ch = getc() ; 
            int f = 0 ;
            for(;!isdigit(ch);ch = getc()) f = (ch == '-') ? 1 : 0 ;
            x = 0;
            for(;isdigit(ch);ch = getc()) x = (x<<3) + (x<<1) + (ch^48) ;
            return x = f ? -x : x,*this ;
        }
        
        inline Read& operator >> (char &c) {
            c = getc() ; 
            while(c == ' ' || c == '\n') c = getc() ; 
            return *this; 
        }
        
        inline Read& operator >> (char *str) {
            int len = 0;
            char ch = getc() ;
            while(ch == ' ' || ch == '\n') ch = getc() ;
            while(ch != ' ' && ch != '\n' && ch != '\r' && ch != EOF) str[len++] = ch,ch = getc() ;
            return str[len] = '\0',*this; 
        }
    } cin ;
    
    struct Write {
        template <typename Tp> 
        inline Write& operator << (Tp x) {
            if(!x) return putc('0'),*this ;
            if(x < 0) putc('-'),x = -x;
            int stk[20],top = 0 ;
            while(x) stk[++top] = x%10,x/=10 ;
            while(top) putc(stk[top--] + '0') ;
            return *this ;
        }
        
        inline Write& operator << (const char ch) {
            return putc(ch),*this; 
        } 
        
        inline Write& operator << (char *str) {
            int cur = 0 ;
            while(str[cur]) putc(str[cur++]) ;
            return *this ; 
        }
        
        inline Write& operator << (const char *str) {
            int cur = 0 ;
            while(str[cur]) putc(str[cur++]) ;
            return *this ;
        }
    } cout ;
    
    template<typename Tp> 
    inline Tp max(const Tp &a,const Tp &b){
        return a>b?a:b;
    }
    
    template<typename Tp,typename... Rst> 
    Tp max(const Tp &a,const Rst... rst) {
        return max(a,max(rst...));
    }
    
    template<typename Tp> 
    inline Tp min(const Tp &a,const Tp &b) {
        return a<b?a:b;
    }
    
    template<typename Tp,typename... Rst> 
    Tp min(const Tp &a,const Rst... rst) {
        return min(a,min(rst...));
    }
}
using hpy::cin;
using hpy::cout;
using hpy::max;
using hpy::min;

int n,m,k,t;

inline void solve() {
    cin >> n >> m >> k;
    cout << ((n*m-1==k) ? "YES\n":"NO\n") ;
}

int main(int argc,const char **argv) {
    cin >> t ;
    while(t--) solve() ;
    return hpy::flush(),0 ;
}
### Prompt

Develop a solution in CPP to the problem described below:

There is a n × m grid. You are standing at cell (1, 1) and your goal is to finish at cell (n, m).

You can move to the neighboring cells to the right or down. In other words, suppose you are standing at cell (x, y). You can: 

  * move right to the cell (x, y + 1) — it costs x burles; 
  * move down to the cell (x + 1, y) — it costs y burles. 



Can you reach cell (n, m) spending exactly k burles?

Input

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

The first and only line of each test case contains three integers n, m, and k (1 ≤ n, m ≤ 100; 0 ≤ k ≤ 10^4) — the sizes of grid and the exact amount of money you need to spend.

Output

For each test case, if you can reach cell (n, m) spending exactly k burles, print YES. Otherwise, print NO.

You may print every letter in any case you want (so, for example, the strings yEs, yes, Yes and YES are all recognized as positive answer).

Example

Input


6
1 1 0
2 2 2
2 2 3
2 2 4
1 4 3
100 100 10000


Output


YES
NO
YES
NO
YES
NO

Note

In the first test case, you are already in the final cell, so you spend 0 burles.

In the second, third and fourth test cases, there are two paths from (1, 1) to (2, 2): (1, 1) → (1, 2) → (2, 2) or (1, 1) → (2, 1) → (2, 2). Both costs 1 + 2 = 3 burles, so it's the only amount of money you can spend.

In the fifth test case, there is the only way from (1, 1) to (1, 4) and it costs 1 + 1 + 1 = 3 burles.

### Response

```cpp
/*If you are full of hope,you will be invincible.*/
#include <bits/stdc++.h>
typedef long long ll ;
typedef unsigned long long u64 ;  
std::mt19937 rnd(time(nullptr)+(unsigned long long)(new char)+20051107);
namespace hpy {
    constexpr int HL = 1<<20 ;
    char buf[HL],buff[HL],*t1 = buf,*t2 = buf,*T = buff;
    
    inline char getc() {
        #ifndef feicheng
            return (t1 == t2 && (t2 = (t1 = buf) + fread(buf,1,HL,stdin),t1 == t2)?EOF:*t1++) ;
        #else
            return getchar();
        #endif
    }
    
    inline void flush() {
        fwrite(buff,1,T-buff,stdout),T = buff;
    }
    
    inline void putc(const char ch) {
        if(T == buff + HL) flush() ;
        *T ++ = ch;
    }

    struct Read {
        template <typename Tp>
        inline Read& operator >>  (Tp &x) {
            char ch = getc() ; 
            int f = 0 ;
            for(;!isdigit(ch);ch = getc()) f = (ch == '-') ? 1 : 0 ;
            x = 0;
            for(;isdigit(ch);ch = getc()) x = (x<<3) + (x<<1) + (ch^48) ;
            return x = f ? -x : x,*this ;
        }
        
        inline Read& operator >> (char &c) {
            c = getc() ; 
            while(c == ' ' || c == '\n') c = getc() ; 
            return *this; 
        }
        
        inline Read& operator >> (char *str) {
            int len = 0;
            char ch = getc() ;
            while(ch == ' ' || ch == '\n') ch = getc() ;
            while(ch != ' ' && ch != '\n' && ch != '\r' && ch != EOF) str[len++] = ch,ch = getc() ;
            return str[len] = '\0',*this; 
        }
    } cin ;
    
    struct Write {
        template <typename Tp> 
        inline Write& operator << (Tp x) {
            if(!x) return putc('0'),*this ;
            if(x < 0) putc('-'),x = -x;
            int stk[20],top = 0 ;
            while(x) stk[++top] = x%10,x/=10 ;
            while(top) putc(stk[top--] + '0') ;
            return *this ;
        }
        
        inline Write& operator << (const char ch) {
            return putc(ch),*this; 
        } 
        
        inline Write& operator << (char *str) {
            int cur = 0 ;
            while(str[cur]) putc(str[cur++]) ;
            return *this ; 
        }
        
        inline Write& operator << (const char *str) {
            int cur = 0 ;
            while(str[cur]) putc(str[cur++]) ;
            return *this ;
        }
    } cout ;
    
    template<typename Tp> 
    inline Tp max(const Tp &a,const Tp &b){
        return a>b?a:b;
    }
    
    template<typename Tp,typename... Rst> 
    Tp max(const Tp &a,const Rst... rst) {
        return max(a,max(rst...));
    }
    
    template<typename Tp> 
    inline Tp min(const Tp &a,const Tp &b) {
        return a<b?a:b;
    }
    
    template<typename Tp,typename... Rst> 
    Tp min(const Tp &a,const Rst... rst) {
        return min(a,min(rst...));
    }
}
using hpy::cin;
using hpy::cout;
using hpy::max;
using hpy::min;

int n,m,k,t;

inline void solve() {
    cin >> n >> m >> k;
    cout << ((n*m-1==k) ? "YES\n":"NO\n") ;
}

int main(int argc,const char **argv) {
    cin >> t ;
    while(t--) solve() ;
    return hpy::flush(),0 ;
}
```