You are given two integers n and m. You have to construct the array a of length n consisting of non-negative integers (i.e. integers greater than or equal to zero) such that the sum of elements of this array is exactly m and the value ∑_{i=1}^{n-1} |a_i - a_{i+1}| is the maximum possible. Recall that |x| is the absolute value of x.

In other words, you have to maximize the sum of absolute differences between adjacent (consecutive) elements. For example, if the array a=[1, 3, 2, 5, 5, 0] then the value above for this array is |1-3| + |3-2| + |2-5| + |5-5| + |5-0| = 2 + 1 + 3 + 0 + 5 = 11. Note that this example doesn't show the optimal answer but it shows how the required value for some array is calculated.

You have to answer t independent test cases.

Input

The first line of the input contains one integer t (1 ≤ t ≤ 10^4) — the number of test cases. Then t test cases follow.

The only line of the test case contains two integers n and m (1 ≤ n, m ≤ 10^9) — the length of the array and its sum correspondingly.

Output

For each test case, print the answer — the maximum possible value of ∑_{i=1}^{n-1} |a_i - a_{i+1}| for the array a consisting of n non-negative integers with the sum m.

Example

Input


5
1 100
2 2
5 5
2 1000000000
1000000000 1000000000


Output


0
2
10
1000000000
2000000000

Note

In the first test case of the example, the only possible array is [100] and the answer is obviously 0.

In the second test case of the example, one of the possible arrays is [2, 0] and the answer is |2-0| = 2.

In the third test case of the example, one of the possible arrays is [0, 2, 0, 3, 0] and the answer is |0-2| + |2-0| + |0-3| + |3-0| = 10.
import java.util.*;
import java.io.*;
public class Solution{
  
    static long mod=998244353 ;
    static boolean f=true;
    static class pair implements Comparable<pair>{
        int a,b;
        pair(int x,int y){
            a=x;b=y;
        }
        public int compareTo(pair t){
            if(t.a==this.a)
            return t.b-this.b;
            return this.a-t.a;
        }
    }
    public static ArrayList<pair> bfs(String[] a,int r,int c){
        ArrayList<pair> ans=new ArrayList<>();
        Queue<pair> q=new LinkedList<>();
        int[][] dxy={{-1,0,1,0},{0,-1,0,1}};
        q.add(new pair(r,c));
        HashSet<String> h=new HashSet<>();
        while(!q.isEmpty()){
            pair f=q.poll();
            ans.add(f);h.add(f.a+" "+f.b);
            for(int i=0;i<4;i++){
                int dx=f.a+dxy[0][i];
                int dy=f.b+dxy[1][i];
                if(dx<0||dy<0||dx>=a.length||dy>=a.length||h.contains(dx+" "+dy)||
                a[dx].charAt(dy)=='1')
                continue;
                q.add(new pair(dx,dy));
                h.add(dx+" "+dy);
            }
        }
        return ans;
    }    

    /*
    1 1 1 1 1 
3 3 3 
2 3 3 2 1 3 
1 
2 2 2 2 
4 4 4 1 4 
*/
    public static int pow(int a, int n) {
		long ans = 1;
		long base = a;
		while (n != 0) {
			if ((n & 1) == 1) {
				ans *= base;
				ans %= 1000000007;
			}
			base = (base * base) % 1000000007;
			n >>= 1;
		}
		return (int) ans % 1000000007;
	}
	public static int find(int x){
	    int i=1;int f=0;
	    while(x>0){
	        if((x&1)==0)f=i;
	        x>>=1;i++;
	    }
	    return f;
	}
	public static boolean good(int x){
	    
	    if((((x+1)&x))==0)
	    return true;
	    return false;
	}
	public static long f(long n){
	  
	   long val=2;
	   long preval=0;int i=1;
	   while(n>=val){
	       i++;
	       preval=val;
	       val=3*i+val-1;
	       
	   }
	   
	   return preval;
	   
	}
	public static boolean bfs(ArrayList<Integer>[] a,int n,int[] b){
	    Queue<Integer> p=new LinkedList<>();
	    boolean v[]=new boolean[n];
	    v[0]=true;int k=0;
	    if(b[0]!=0)return false;
	    p.add(0);int c=1;
	    HashSet<Integer> h=new HashSet<Integer>();
	    h.add(0);
	    while(!p.isEmpty()){
	        int f=p.poll();k++;
	        if(h.contains(f))h.remove(f);
	        else return false;
	        v[f]=true;
	        c--;
	
	       for(int i:a[f]){
	           if(!v[i]){
	           p.add(i);v[i]=true;}
	       }
	          if(c==0){
	              c=p.size();
	       if(h.size()!=0)return false;
	       for(int j=k;j<k+p.size();j++)
	       h.add(b[j]);
	   }
	    }
	    return true;
	    
	}
	public static int mi(int[] a,int k,int[] dp,int n){
	    int max=0;
	    for(int i=1;i*i<=k;i++){
	      //  System.out.println("fact "+i);
	        if(k%i==0&&(a[i-1]<a[k-1])){
	            
	      //  System.out.println(i+" "+dp[i-1]+" "+a[i-1]+" ");
	        max=Math.max(dp[i-1],max);}
	        if(k%i==0&&(a[k/i-1]<a[k-1])){
	            
	      //  System.out.println(i+" "+dp[i-1]+" "+a[i-1]+" ");
	        max=Math.max(dp[k/i-1],max);}
	        
	    }
	    return max;
	}
	    public static long dfs(ArrayList<Integer> a[],int n,boolean[] v,boolean s[]
	    ,long c[],int x){
     v[n]=true;
     if(n==x)
     s[n]=true;
     c[n]=1;
      
        for(int i=0;i<a[n].size();i++){
            if(!v[a[n].get(i)]){
         c[n]+= dfs(a,a[n].get(i),v,s,c,x);
         s[n]|=s[a[n].get(i)];
            }
           
        }
        return c[n];
        
    }
    public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
 
			int t = s.nextInt();
	StringBuilder st=new StringBuilder();
		while(t-- > 0) {
long n=s.nextLong();
long m=s.nextLong();
if(n==1)
st.append(0+"\n");
else if(n==2)
st.append(m+"\n");
else
st.append(2*m+"\n");
}
System.out.println(st);
   
/*
6 23 21
1 1000 0
2 1 2
6 45 46
2 2 1
3 4 2
4 4 3
*/


  
	
        
    }
}