Leo has developed a new programming language C+=. In C+=, integer variables can only be changed with a "+=" operation that adds the right-hand side value to the left-hand side variable. For example, performing "a += b" when a = 2, b = 3 changes the value of a to 5 (the value of b does not change).

In a prototype program Leo has two integer variables a and b, initialized with some positive values. He can perform any number of operations "a += b" or "b += a". Leo wants to test handling large integers, so he wants to make the value of either a or b strictly greater than a given value n. What is the smallest number of operations he has to perform?

Input

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

Each of the following T lines describes a single test case, and contains three integers a, b, n (1 ≤ a, b ≤ n ≤ 10^9) — initial values of a and b, and the value one of the variables has to exceed, respectively.

Output

For each test case print a single integer — the smallest number of operations needed. Separate answers with line breaks.

Example

Input


2
1 2 3
5 4 100


Output


2
7

Note

In the first case we cannot make a variable exceed 3 in one operation. One way of achieving this in two operations is to perform "b += a" twice.
import java.io.*;
import java.util.*;

public class A implements Runnable {
	FastReader sc;
	PrintWriter out;
	long mod = (long)1e9 + 7;
	
	
	void solve() 
	{	
		int tc = sc.ni();
		outer: while(tc-- > 0)
		{
			long a = sc.nl();
			long b = sc.nl();
			long n = sc.nl();
			
			long t = Math.min(a, b);
			b = Math.max(a, b);
			a = t;
			
			int cnt = 0;
			while(true)
			{	
				cnt++;
				t = b;
				b = a+b;
				a = t;
				
				if(b > n)
				{
					break;
				}
			}
			
			out.println(cnt);
		}
	}
	
	class Pair implements Comparable<Pair>
	{
		
		int x;
		int y;
		
		Pair(int x,int y)
		{
			this.x = x;
			this.y = y;
		}
		
		public int compareTo(Pair o) 
		{
			
			if(x != o.x)
			{
				if(x > o.x) return 1;  //increasing order
				else return -1;	
			}
			else
			{
				if(y > o.y) return 1;  //increasing order
				else return -1;	
			}
		}
	}

	public void run() 
	{
		out = new PrintWriter(System.out);
		sc = new FastReader();
		solve();
		out.flush();
	}

	public static void main(String[] args) 
	{
		new Thread(null, new A(), "Main", 1 << 28).start();
	}

	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 ni() 
        { 
            return Integer.parseInt(next()); 
        } 
  
        long nl() 
        { 
            return Long.parseLong(next()); 
        } 
  
        double nd() 
        { 
            return Double.parseDouble(next()); 
        } 
  
        String nln() 
        { 
            String str = ""; 
            try
            { 
                str = br.readLine(); 
            } 
            catch (IOException e) 
            { 
                e.printStackTrace(); 
            } 
            return str; 
        } 
        

		int[] nia(int n) {
			int[] ar = new int[n];
			for (int i = 0; i < n; i++)
				ar[i] = ni();
			return ar;
		}
		
		long[] nla(int n) {
			long[] ar = new long[n];
			for (int i = 0; i < n; i++)
				ar[i] = nl();
			return ar;
		}

	    
		int[][] nim(int n, int m) {
			int[][] ar = new int[n][];
			for (int i = 0; i < n; i++) {
				ar[i] = nia(m);
			}
			return ar;
		}

		long[][] nlm(int n, int m) {
			long[][] ar = new long[n][];
			for (int i = 0; i < n; i++) {
				ar[i] = nla(m);
			}
			return ar;
		}
		
		String reverse(String s)
		{
			StringBuilder r = new StringBuilder(s);
			return r.reverse().toString();
		}
		
		void merge1(int arr[], int l, int m, int r)
	    {
	        int n1 = m - l + 1;
	        int n2 = r - m;
	        int L[] = new int [n1];
	        int R[] = new int [n2];
	        for (int i=0; i<n1; ++i)
	            L[i] = arr[l + i];
	        for (int j=0; j<n2; ++j)
	            R[j] = arr[m + 1+ j];
	        int i = 0, j = 0;
	        int k = l;
	        while (i < n1 && j < n2)
	        {
	            if (L[i]<=R[j])
	            {
	                arr[k] = L[i];
	                i++;
	            }
	            else
	            {
	                arr[k] = R[j];
	                j++;
	            }
	            k++;
	        }
	        while (i < n1)
	        {
	            arr[k] = L[i];
	            i++;
	            k++;
	        }
	        while (j < n2)
	        {
	            arr[k] = R[j];
	            j++;
	            k++;
	        }
	    }
	    void sort1(int arr[], int l, int r)
	    {
	        if (l < r)
	        {
	            int m = (l+r)/2;
	            sort1(arr, l, m);
	            sort1(arr , m+1, r);
	            merge1(arr, l, m, r);
	        }
	    }
    }
}