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.io.*;
import java.io.IOException;

import java.util.*;
//import javafx.util.Pair; 
//import java.util.concurrent.LinkedBlockingDeque;

//import sun.net.www.content.audio.wav;



    
   public  class Codeforces {
        
        public static long mod = (long)Math.pow(10, 9)+7 ;
        public static double epsilon=0.00000000008854;//value of epsilon
        public static InputReader sc = new InputReader(System.in);
        public static PrintWriter pw = new PrintWriter(System.out);
        public static int firstNode(int a,HashMap<Integer,Integer> p){
            if(p.containsKey(a)){
                p.put(a, firstNode(p.get(a), p));
            }
            else return a;
            return p.get(a);
        }
        public static void Union(int a,int b,HashMap<Integer,Integer> p){
            //int a=firstNode(a1, p);
            //int b=firstNode(b1, p);
            /*if(a!=b){
                if(r[a]<r[b]){
                    p[a]=b;
                }
                else if(r[a]>r[b]){
                    p[b]=a;
                }
                else{
                    r[b]++;
                    p[a]=b;
                }
            }*/
            a=firstNode(a, p);
            b=firstNode(b, p);
            if(a!=b)
            p.put(a, b);//if no rank than 
        }
        public static ArrayList<ArrayList <Integer>> GetGraph(int n,int m){
            ArrayList<ArrayList <Integer>> a=new ArrayList<>();
            for(int i=0;i<n;i++){
                a.add(new ArrayList<>());
            }
            for(int i=0;i<m;i++){
                int u=sc.nextInt()-1;
                int v=sc.nextInt()-1;
                a.get(u).add(v);
                a.get(v).add(u);
            } 
            return a;
        }
        public static void dfs(char a[][],int vis[][],int x,int y){
            int n=a.length;
            int m=a[0].length;
            if(x<0||x>=n||y<0||y>=m){
                return;
            }
            if(vis[x][y]==1)
            return;
            if(a[x][y]=='G'||a[x][y]=='.'){
                vis[x][y]=1;
                dfs(a, vis, x+1, y);
                dfs(a, vis, x-1, y);
                dfs(a, vis, x, y+1);
                dfs(a, vis, x, y-1);
            }
        }
        public static void main(String[] args) {
            // code starts..
           int q=sc.nextInt();
           while(q-->0){
               long min=Long.MAX_VALUE;
               long a=sc.nextLong();
               long b=sc.nextLong();
               long c=sc.nextLong();
               long t=2;
               min=Math.abs(a+b-2*c);
               long l=0,r=100000000;
               while(l<=r){
                   long mid=(l+r)/2;
                   //pw.println("kefnkenf "+mid);
                   long v=(2*mid+1)*c-mid*(a+b)-a;
                   if(v>0){
                       r=mid-1;
                   }
                   else{
                       l=mid+1;
                   }
                   
                   if((2*mid+1)*min>t*Math.abs(v)||((2*mid+1)*min==t*Math.abs(v)&&t>(2*mid+1))){
                       t=2*mid+1;
                       min=Math.abs(v);
                   }
                   
                  // pw.println(t+" "+min);
               }
               
            //pw.println(t+" "+min);
               pw.println(t);
           }
            // Code ends...
            pw.flush();
            pw.close();
        }
       
        public static Comparator<Integer[]> column(int i){
            return 
            new Comparator<Integer[]>() {
                @Override
                public int compare(Integer[] o1, Integer[] o2) {
                    return o1[i].compareTo(o2[i]);//for ascending
                    //return o2[i].compareTo(o1[i]);//for descending
                }
            };
        }
        public static String reverseString(String s){
            StringBuilder input1 = new StringBuilder(); 
            input1.append(s);  
            input1 = input1.reverse();
            return input1.toString();
        }
        public static int[] scanArray(int n){
            int a[]=new int [n];
            for(int i=0;i<n;i++)
            a[i]=sc.nextInt();
    
            return a;
        }
        public static long[] scanLongArray(int n){
            long a[]=new long [n];
            for(int i=0;i<n;i++)
            a[i]=sc.nextLong();
    
            return a;
        }
        public static String [] scanStrings(int n){
            String a[]=new String [n];
            for(int i=0;i<n;i++)
            a[i]=sc.nextLine();
    
            return a;
        }
        
    }
    
    class InputReader {
    
            private final InputStream stream;
            private final byte[] buf = new byte[8192];
            private int curChar, snumChars;
            private SpaceCharFilter filter;
    
            public InputReader(InputStream stream) {
                this.stream = stream;
            }
    
            public int snext() {
                if (snumChars == -1)
                    throw new InputMismatchException();
                if (curChar >= snumChars) {
                    curChar = 0;
                    try {
                        snumChars = stream.read(buf);
                    } catch (IOException e) {
                        throw new InputMismatchException();
                    }
                    if (snumChars <= 0)
                        return -1;
                }
                return buf[curChar++];
            }
    
            public int nextInt() {
                int c = snext();
                while (isSpaceChar(c)) {
                    c = snext();
                }
                int sgn = 1;
                if (c == '-') {
                    sgn = -1;
                    c = snext();
                }
                int res = 0;
                do {
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = snext();
                } while (!isSpaceChar(c));
                return res * sgn;
            }
    
            public long nextLong() {
                int c = snext();
                while (isSpaceChar(c)) {
                    c = snext();
                }
                int sgn = 1;
                if (c == '-') {
                    sgn = -1;
                    c = snext();
                }
                long res = 0;
                do {
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    res *= 10;
                    res += c - '0';
                    c = snext();
                } while (!isSpaceChar(c));
                return res * sgn;
            }
    
            public int[] nextIntArray(int n) {
                int a[] = new int[n];
                for (int i = 0; i < n; i++) {
                    a[i] = nextInt();
                }
                return a;
            }
    
            public String readString() {
                int c = snext();
                while (isSpaceChar(c)) {
                    c = snext();
                }
                StringBuilder res = new StringBuilder();
                do {
                    res.appendCodePoint(c);
                    c = snext();
                } while (!isSpaceChar(c));
                return res.toString();
            }
    
            public String nextLine() {
                int c = snext();
                while (isSpaceChar(c))
                    c = snext();
                StringBuilder res = new StringBuilder();
                do {
                    res.appendCodePoint(c);
                    c = snext();
                } while (!isEndOfLine(c));
                return res.toString();
            }
    
            public boolean isSpaceChar(int c) {
                if (filter != null)
                    return filter.isSpaceChar(c);
                return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
            }
    
            private boolean isEndOfLine(int c) {
                return c == '\n' || c == '\r' || c == -1;
            }
    
            public interface SpaceCharFilter {
                public boolean isSpaceChar(int ch);
            }
        }
        class SegmentTree{
            int s[],n;
            SegmentTree(int a[]){
                n=a.length;
                int l=(int)Math.ceil(Math.log(n)/Math.log(2));
                l=2*(int)Math.pow(2,l)-1;
                s=new int[l];
                createSegmentTreeUtil(a, 0, 0, a.length-1);
            }
            
            int createSegmentTreeUtil(int a[],int root,int l,int r){
                if(l==r)
                s[root]=a[l];
                else
                s[root]= Compare(createSegmentTreeUtil(a, 2*root+1, l, (l+r)/2), createSegmentTreeUtil(a,2*root+2, (l+r)/2+1,r));
                return s[root];
            }
            int getValue(int gl,int gr){
                return getValueUtil(0, 0, n-1, gl, gr);
            }
            int getValueUtil(int root,int l,int r,int gl,int gr){
                if(l>=gl&&r<=gr){
                    return s[root];
                }
                if(l>gr||r<gl){
                    return 0;
                }
                return Compare(getValueUtil(2*root+1, l, (l+r)/2, gl, gr), getValueUtil(2*root+2, (l+r)/2+1, r, gl, gr));
            }
            void update(int value,int index){
                updateUtil(value, index,0,0,n-1);
            }
            int updateUtil(int p,int k,int root,int l,int r){
                if(l==r&&l==k){
                    return s[root]=p;
                }
                else if(l>k||r<k)
                return s[root];
                else{
                    return s[root]=Compare(updateUtil(p, k, 2*root+1, l, (l+r)/2), updateUtil(p, k, 2*root+2,(l+r)/2+1,r ));
                }
            }
            int Compare(int a,int b){
                return Math.max(a, b);
            }
        }
        