You are given two integers a and m. Calculate the number of integers x such that 0 ≤ x < m and \gcd(a, m) = \gcd(a + x, m).

Note: \gcd(a, b) is the greatest common divisor of a and b.

Input

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

Next T lines contain test cases — one per line. Each line contains two integers a and m (1 ≤ a < m ≤ 10^{10}).

Output

Print T integers — one per test case. For each test case print the number of appropriate x-s.

Example

Input


3
4 9
5 10
42 9999999967


Output


6
1
9999999966

Note

In the first test case appropriate x-s are [0, 1, 3, 4, 6, 7].

In the second test case the only appropriate x is 0.
import java.io.*;
import java.util.*;

public class D implements Runnable {
	FastReader sc;
	PrintWriter out;
	long mod = (long)1e9 + 7;
	
	long gcd(long a,long b)
	{
		if(a == 0) return b;
		if(b == 0) return a;
		
		return gcd(b,a%b);
	}
	
	long phi(long n)
	{	
		long result = n;
		for(long i = 2; i*i <= n; i++)
		{	
			if(n%i == 0)
			{
				while(n%i == 0)
				{
					n /= i;
				}
				
				result -= result/i;
			}
		}
		
		if(n > 1)
		{
			result -= result/n;
		}
		return result;
	}
	
	void solve() 
	{		
		
		int tc = sc.ni();
		outer: while(tc-- > 0)
		{
			long a = sc.nl();
			long m = sc.nl();
			
			long g = gcd(a,m);
			
			long p = m/g;
			
			long ans = phi(p);
			
			out.println(ans);
		}
	}
	

	
	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 D(), "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);
	        }
	    }
    }
}