There are two infinite sources of water:

  * hot water of temperature h; 
  * cold water of temperature c (c < h). 



You perform the following procedure of alternating moves:

  1. take one cup of the hot water and pour it into an infinitely deep barrel; 
  2. take one cup of the cold water and pour it into an infinitely deep barrel; 
  3. take one cup of the hot water ... 
  4. and so on ... 



Note that you always start with the cup of hot water.

The barrel is initially empty. You have to pour at least one cup into the barrel. The water temperature in the barrel is an average of the temperatures of the poured cups.

You want to achieve a temperature as close as possible to t. So if the temperature in the barrel is t_b, then the absolute difference of t_b and t (|t_b - t|) should be as small as possible.

How many cups should you pour into the barrel, so that the temperature in it is as close as possible to t? If there are multiple answers with the minimum absolute difference, then print the smallest of them.

Input

The first line contains a single integer T (1 ≤ T ≤ 3 ⋅ 10^4) — the number of testcases.

Each of the next T lines contains three integers h, c and t (1 ≤ c < h ≤ 10^6; c ≤ t ≤ h) — the temperature of the hot water, the temperature of the cold water and the desired temperature in the barrel.

Output

For each testcase print a single positive integer — the minimum number of cups required to be poured into the barrel to achieve the closest temperature to t.

Example

Input


3
30 10 20
41 15 30
18 13 18


Output


2
7
1

Note

In the first testcase the temperature after 2 poured cups: 1 hot and 1 cold is exactly 20. So that is the closest we can achieve.

In the second testcase the temperature after 7 poured cups: 4 hot and 3 cold is about 29.857. Pouring more water won't get us closer to t than that.

In the third testcase the temperature after 1 poured cup: 1 hot is 18. That's exactly equal to t.
  
import java.util.*;
import java.io.*;
public class Main {
    static FastReader in=new FastReader();
    static StringBuilder Sd=new StringBuilder();
    static List<Integer>Gr[]; 
    static long Mod=998244353;
    static Map<Integer,Integer>map=new HashMap<>();
    public static void main(String [] args) {
    	//Dir by MohammedElkady
    	int t=in.nextInt();
    	while(t-->0) {
    		long h=in.nextLong(),c=in.nextLong(),tt=in.nextLong();
    		if(h==tt) {Soutln("1");}
    		else if((h+c)>=tt*2) {Soutln("2 ");}
    		else {
    			long ans=1L,diff=Long.MAX_VALUE-1;
    			diff=h-tt;
    			if(diff*3<=Math.abs(tt*3-(h+h+c))) {
    				Soutln("1");
    			}
    			else {
    			long x=h-tt,xx=0;
    			x/=(2*tt-h-c);
    			xx=x+1;
    			long lop=Math.abs((tt*(x*2+1)-x*(h+c)-h)*(xx*2+1)),cop=Math.abs((tt*(xx*2+1)-xx*(h+c)-h)*(x*2+1));
    			if(lop>cop) {Soutln(2*xx+1+" ");}
    			else Soutln(2*x+1+" ");
    			}
    		}
    	}
    Sclose();
}
    static String Make_best(StringBuilder Sl) {
    	StringBuilder Sx=Sl,Sy=Sl,Sw=Sl;
    	while(!Sx.toString().equals(new StringBuilder(Sw.toString()).reverse().toString())) {
    		Sx.replace(0, 1, "");
    		Sx=Sw;
    	System.out.println(Sx.toString());	
    	}
    	while(!Sy.toString().equals(new StringBuilder(Sy.toString()).reverse().toString())) {
    		Sy.replace(Sy.length()-2, Sy.length()-1, "");
    		
    	}
    	if(Sx.length()>Sy.length())Sl=Sx;
    	else Sl=Sy;
    	return Sl.toString();
    }
    
    static long power(long x, long y, long p) 
    { 
          
        // Initialize result 
        long res = 1; 
      
        // Update x if it is more than or 
        // equal to p 
        x = x % p; 
                      
        while (y > 0) 
        { 
              
            // If y is odd, multiply x 
            // with result 
            if (y % 2 == 1) 
                res = (res * x) % p; 
      
            // y must be even now 
            y = y >> 1; // y = y/2 
            x = (x * x) % p; 
        } 
          
        return res; 
    } 
      
    // Returns n^(-1) mod p 
    static long modInverse(long n, long p) 
    { 
        return power(n, p-2, p); 
    } 
      
    // Returns nCr % p using Fermat's 
    // little theorem. 
    static long nCrModPFermat(int n, int r, 
                                    long p) 
    { 
          
        // Base case 
        if (r == 0) 
            return 1; 
      
        // Fill factorial array so that we 
        // can find all factorial of r, n 
        // and n-r 
        long[] fac = new long[n+1]; 
        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; 
    } 
    static long fac(int n , int m,int l) {
    	long res=1;
    	for(int i=l,u=1;i<=n||u<=m;i++,u++) {
    		if(i<=n) {res*=i;}
    		if(u<=m) {res/=u;}
    		while(res>Mod)
    		res-=Mod;
    	}
    	return res;
    }
    static long posation(int n) {
     long res=1;
     for(int i=0;i<n-3;i++) {res*=2L;
     while(res>Mod)
     res-=Mod;
     while(res<=0)res+=Mod;}
     return res;
    }
   
    static long gcd(long g,long x){
        if(x<1)return g;
        else return gcd(x,g%x);
    }
    //array fill
    static long[]filllong(int n){long a[]=new long[n];for(int i=0;i<n;i++)a[i]=in.nextLong();return a;}
    static int[]fillint(int n){int a[]=new int[n];for(int i=0;i<n;i++)a[i]=in.nextInt();return a;}
    //OutPut Line
    static void Sout(String S) {Sd.append(S);}
    static void Soutln(String S) {Sd.append(S+"\n");}
    static void Soutf(String S) {Sd.insert(0, S);}
    static void Sclose() {System.out.println(Sd);}
    static void Sclean() {Sd=new StringBuilder();}
}
class node implements Comparable<node>{
int x,t;
	node(int x,int p){
		this.x=x;
		this.t=p;
	}
	@Override
	public int compareTo(node o) {
       return (t-o.t);
	}
}
class FastReader
    {
        BufferedReader br;
        StringTokenizer st;
 
        public FastReader()
        {
            br = new BufferedReader(new
                     InputStreamReader(System.in));
        }
 
        String next()
        {
            while (st == null || !st.hasMoreElements())
            {
                try
                {
                    st = new StringTokenizer(br.readLine());
                }
                catch (IOException  e)
                {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }
 
        int nextInt()
        {
            return Integer.parseInt(next());
        }
 
        long nextLong()
        {
            return Long.parseLong(next());
        }
 
        double nextDouble()
        {
            return Double.parseDouble(next());
        }
 
        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
}
 
class Sorting{
 
 public static node[] bucketSort(node[] array, int bucketCount) {
 
 if (bucketCount <= 0) throw new IllegalArgumentException("Invalid bucket count");
 
 if (array.length <= 1) return array; //trivially sorted
 
 
 
 int high = array[0].t;
 
 int low = array[0].t;
 
 for (int i = 1; i < array.length; i++) { //find the range of input elements
 
 if (array[i].t > high) high = array[i].t;
 
 if (array[i].t < low) low = array[i].t;
 
 }
 
 double interval = ((double)(high - low + 1))/bucketCount; //range of one bucket
 
 
 ArrayList<node> buckets[] = new ArrayList[bucketCount];
 
 for (int i = 0; i < bucketCount; i++) { //initialize buckets
 
 buckets[i] = new ArrayList();
 
 }
 
 
 
 for (int i = 0; i < array.length; i++) { //partition the input array
 
 buckets[(int)((array[i].t - low)/interval)].add(array[i]);
 
 }
 
 
 int pointer = 0;
 
 for (int i = 0; i < buckets.length; i++) {
 
 Collections.sort(buckets[i]); //mergeSort
 
 for (int j = 0; j < buckets[i].size(); j++) { //merge the buckets
 
 array[pointer] = buckets[i].get(j);
 
 pointer++;
 
 }
 
}
 
return array;
 
}
}