#include <bits/stdc++.h>
#include <iomanip>
#define FAST std::ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0);
#define DECIMAL(n)  std::cout << std::fixed;std::cout << std::setprecision(n);
#define mod 1000000007
#define mp make_pair
#define pb push_back
#define fi first 
#define se second
#define ALL(v) v.begin(), v.end()
#define SORT(v) sort(ALL(v))  
#define REVERSE(v) reverse(ALL(v))
#define endl "\n"
#define maxc(v) max_element(all(v))
#define minc(v) min_element(all(v))
#define GCD(m,n) __gcd(m,n)
#define debug cerr<<"bhau"<<endl
#define debugv(x) cerr<<x<<endl
#define inputarr(a,n) for(int i=0;i<n;++i) cin>>a[i]
#define printarr(a,n) for(int i=0;i<n;++i) cout<<a[i]<<" "
#define initarr(a,n,x) for (int i=0;i<n;++i) a[i]=x
#define ll  long long
#define ld long double 
#define pii pair<ll, ll>   
#define vi vector<ll>  
#define vvi vector<vi > 
#define vii vector<pii >
#define eps 1e-9
using namespace std;
//int a[100][100];
/*const int mx=1e6+1;
bool vis[mx]={false};
ll dist[mx];
vector<pii>adj[mx];
priority_queue<pii,vector<pii>,greater<pii> > pq;
void dijkstra()
{
    pq.push(make_pair(0,1));
    dist[1]=0;
    while(!pq.empty())
    {
        ll u=pq.top().second;
        pq.pop();
        if(vis[u])
        continue;
 
        vis[u]=true;
        vector<pii>::iterator it;
        for(it=adj[u].begin();it!=adj[u].end();it++)
        {
            ll v=(*it).first;
            ll weight =(*it).second;
            //cout<<v<<" "<<dist[v]<<" "<<(dist[u]+weight)<<endl;
            if( (dist[v]>dist[u]+weight))
            {
                dist[v]=dist[u]+weight;
                pq.push(make_pair(dist[v],v));
            }
        }
    }
}*/
 
/*int V,k;
struct node
{
	ll src,dest;
	ll wght;
};
ll par[105],rnk[105];
ll Find(ll nd)
{
	if(par[nd]!=nd)
		par[nd]=Find(par[nd]);
	return par[nd];
}
void Union(ll nd1, ll nd2)
{
	ll x=Find(nd1);
	ll y=Find(nd2);
	if(rnk[x]<rnk[y])
		par[x]=y;
	else if(rnk[x]>rnk[y])
		par[y]=x;
	else
	{
		par[y]=x;
		rnk[x]++;
	}
}
bool compare(node n1, node n2)
{
	return n1.wght<n2.wght;
}
ll kruskal(vector<node> g, int n)
{
	vector<node> mst;
	for(int i=0;i<n;++i)
	{
		par[i]=i;
		rnk[i]=0;
	}
	sort(g.begin(),g.end(),compare);
	ll cnt=0,cnt1=0;
	ll ans=0;
	while(cnt!=n-1)
	{
		node ne=g[cnt1++];
		int x=Find(ne.src);
		int y=Find(ne.dest);
		if(x!=y)
		{
			if(ans+ne.wght<=k)
			{ans+=ne.wght;
			mst.push_back(ne);
			Union(x,y);
			cnt++;}
			else
			{
				break;
			}
			
		}
	}
	return cnt;
}
ll dis[105][105];
void floydWarshell(vector<node> g, int n)
{
	for(int i=0;i<V;i++)
	{
		for(int j=0;j<V;j++)
		{
			dis[i][j]=9999;
		}
	}
	for(int i=0;i<V;i++)
	{
		dis[i][i]=0;
	}
	for(int i=0;i<g.size();++i)
	{
		dis[g[i].src][g[i].dest]=g[i].wght;
		//dis[g[i].dest][g[i].src]=g[i].wght;
	}
	for(int k=0;k<n;++k)
	{
		for(int i=0;i<n;++i)
		{
			for(int j=0;j<n;++j)
			{
				if(dis[i][k]+dis[k][j]<dis[i][j])
					dis[i][j]=dis[i][k]+dis[k][j];
			}
		}
	}
	
}
long di[105];
void bellmanford(vector<node> g,ll e)
{
    for(int i=0;i<V;i++)
	{
		di[i]=LONG_MAX;
	}
	di[0]=0;
	for(int i=0;i<V-1;i++)
	{
		for(int j=0;j<e;j++)
		{
            if(di[g[j].src]+g[j].wght<di[g[j].dest])
			di[g[j].dest]=di[g[j].src]+g[j].wght;
		}
	}
}
void topological_sort()
{
	for(ll i=1;i<=n;i++)
	{
		if(!in[i])
		{
			t.push(i);
		}
	}
	while(!t.empty())
	{
		ll u=t.front();
		t.pop();
		ans.push_back(u);
		for(auto i:v[u])
		{
			in[i]-=1;
			val[i]+=val[u]/out[u];
			if(in[i]==0)
			{
				t.push(i);
			}
		}
	}
}
void dfs_util(ll u,vector<ll> g[],vector<bool> &visited)
{
    visited[u]=true;
    //int c=0;
    for(int i=0;i<g[u].size();i++)
    {
        if(visited[g[u][i]]==false)
        {
        dfs_util(g[u][i],g,visited);
        }
    }
}
bool dfs(vector<ll> g[])
{
    vector<bool> visited(V+1,false);
    dfs_util(0,g,visited);
 
    ll count=0;
	for(int i=0;i<V;i++)
	{
		if(visited[i])
		count++;
	}
	if(count==V)
	return true;
 
	else
	return false;
 
}*/
/*void check(vector<ll> g[],ll *vis,ll u,bool &ans)
{
    vis[u]=true;
    for(int i=0;i<g[u].size();i++)
    {
        if(vis[g[u][i]]==0)
        check(g,vis,g[u][i],ans);
        else if(vis[g[u][i]]==1)
        ans=true;
    }
    vis[u]=2;
    
}*/
//int T;
//char s[100007];
   /* ll t;
    cin>>t;
    while(t--)
    {
        ll n,x,sum=0;
        cin>>n>>x;
        int a[n];
        inputarr(a,n);
        int count=1;
        bool b=true;
        while(b)
        {
            count++;
            for(int i=0;i<n;i++)
            {
                if(a[i]%x==0 && (a[i]/x)!=0)
                {
                    if(count!=1)
                        sum+=x*a[i];
					else
                    	sum+=a[i];
                  a[i]=a[i]/x;
                }
                else
                {
                    b=false;
                    break;
                }
            }
//cout<<sum<<endl;
        }
        cout<<sum<<endl;
    }*/
	//ll t;
 
//const int mod = 1000000007;
ll nCr(ll n, ll k)
{
    ll C[n + 1][k + 1];
    ll i, j;
 
    // Caculate value of Binomial Coefficient
    // in bottom up manner
    for (i = 0; i <= n; i++) {
        for (j = 0; j <= min(i, k); j++) {
            // Base Cases
            if (j == 0 || j == i)
                C[i][j] = 1;
 
            // Calculate value using previously
            // stored values
            else
                C[i][j] = C[i - 1][j - 1] + C[i - 1][j];
        }
    }
    return C[n][k];
}
bool isPalindrome(string str) 
{ 
    // Start from leftmost and rightmost corners of str 
    int l = 0; 
    int h = str.size() - 1; 
  
    // Keep comparing characters while they are same 
    while (h > l) 
    { 
        if (str[l++] != str[h--]) 
        { 
            //printf("%s is Not Palindrome", str); 
            return false; 
        } 
    } 
    return true; 
}
double squareRoot(ll number, int precision) 
{ 
    ll start = 0, end = number; 
    ll mid; 
  
    // variable to store the answer 
    double ans; 
  
    // for computing integral part 
    // of square root of number 
    while (start <= end) { 
        mid = (start + end) / 2; 
        if (mid * mid == number) { 
            ans = mid; 
            break; 
        } 
  
        // incrementing start if integral 
        // part lies on right side of the mid 
        if (mid * mid < number) { 
            start = mid + 1; 
            ans = mid; 
        } 
  
        // decrementing end if integral part 
        // lies on the left side of the mid 
        else { 
            end = mid - 1; 
        } 
    } 
  
    // For computing the fractional part 
    // of square root upto given precision 
     double increment = 0.1; 
    for (int i = 0; i < precision; i++) { 
        while (ans * ans <= number) { 
            ans += increment; 
        } 
  
        // loop terminates when ans * ans > number 
        ans = ans - increment; 
        increment = increment / 10; 
    } 
    return ans; 
} 
int main() 
{
   ll t;
   cin>>t;
   while(t--)
   {
       ll r,b,d;
       cin>>r>>b>>d;
       ll s=max(r,b);
       ll q=min(r,b);
       if(s<=(1+d)*q)
       cout<<"YES"<<endl;
       else
       cout<<"NO"<<endl;
   }
}
