Problem: You are given an undirected unweighted connected graph consisting of n vertices and m edges. It is guaranteed that there are no self-loops or multiple edges in the given graph.

Your task is to choose at most ⌊n/2⌋ vertices in this graph so each unchosen vertex is adjacent (in other words, connected by an edge) to at least one of chosen vertices.

It is guaranteed that the answer exists. If there are multiple answers, you can print any.

You will be given multiple independent queries to answer.

Input

The first line contains a single integer t (1 ≤ t ≤ 2 ⋅ 10^5) — the number of queries.

Then t queries follow.

The first line of each query contains two integers n and m (2 ≤ n ≤ 2 ⋅ 10^5, n - 1 ≤ m ≤ min(2 ⋅ 10^5, (n(n-1))/(2))) — the number of vertices and the number of edges, respectively.

The following m lines denote edges: edge i is represented by a pair of integers v_i, u_i (1 ≤ v_i, u_i ≤ n, u_i ≠ v_i), which are the indices of vertices connected by the edge.

There are no self-loops or multiple edges in the given graph, i. e. for each pair (v_i, u_i) there are no other pairs (v_i, u_i) or (u_i, v_i) in the list of edges, and for each pair (v_i, u_i) the condition v_i ≠ u_i is satisfied. It is guaranteed that the given graph is connected.

It is guaranteed that ∑ m ≤ 2 ⋅ 10^5 over all queries.

Output

For each query print two lines.

In the first line print k (1 ≤ ⌊n/2⌋) — the number of chosen vertices.

In the second line print k distinct integers c_1, c_2, ..., c_k in any order, where c_i is the index of the i-th chosen vertex.

It is guaranteed that the answer exists. If there are multiple answers, you can print any.

Example

Input


2
4 6
1 2
1 3
1 4
2 3
2 4
3 4
6 8
2 5
5 4
4 3
4 1
1 3
2 3
2 6
5 6


Output


2
1 3
3
4 3 6

Note

In the first query any vertex or any pair of vertices will suffice.

<image>

Note that you don't have to minimize the number of chosen vertices. In the second query two vertices can be enough (vertices 2 and 4) but three is also ok.

<image>

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;
import java.math.*;
import java.math.BigInteger;


public final class A
{    
	static PrintWriter out = new PrintWriter(System.out); 
	static StringBuilder ans=new StringBuilder();
	static FastReader in=new FastReader();
	static ArrayList<ArrayList<Integer>> g;
	static long mod=(long)1e9+7,INF=Long.MAX_VALUE;
	static boolean set[],col[]; 
	static int par[],tot[],partial[];
	static int D[],P[][];
	static long dp[][],max=0;
	static node1 seg[];
	//static pair moves[]= {new pair(-1,0),new pair(1,0), new pair(0,-1), new pair(0,1)};
	public static void main(String args[])throws IOException
	{				
		int T=i();
		while(T-->0)
		{
			int N=i(),M=i();
			setGraph(N);
			for(int i=0; i<M; i++)
			{
				int a=i(),b=i();
				g.get(a).add(b);
				g.get(b).add(a);
			}
			Queue<Integer> q=new LinkedList<Integer>();
			q.add(1);
			D[1]=0;
			int odd=0,even=0;
			StringBuilder o=new StringBuilder();
			StringBuilder e=new StringBuilder();
			while(q.size()>0)
			{
				int n=q.remove();
				if(D[n]%2==0) 
				{
					e.append(n+" ");
					even++;
				}
				else 
				{
					o.append(n+" ");
					odd++;
				}
				for(int c:g.get(n))
				{
					if(D[c]>D[n]+1)
					{
						D[c]=D[n]+1;
						q.add(c);
					}
				}
			}
			if(even<=odd)
			{
				ans.append(even+"\n");
				ans.append(e+"\n");
			}
			else
			{
				ans.append(odd+"\n");
				ans.append(o+"\n");
			}
		
		}
		out.println(ans);
		out.close();

	}
	static void build(int v,int tl,int tr,long A[])
	{
		if(tl==tr)
		{
			seg[v]=new node1(A[tl],A[tr],1,true);
			return ;
		}
		int tm=(tl+tr)/2;
		build(2*v,tl,tm,A);
		build(2*v+1,tm+1,tr,A);
		seg[v]=merge(seg[2*v],seg[2*v+1]);
	}
	static node1 ask(int v,int tl,int tr,int l,int r)
	{
		if(l>r)return new node1(0,0,0,false);//verify true or false
		if(tl==l && tr==r)return seg[v];
		int tm=(tl+tr)/2;
		node1 a=ask(v*2,tl,tm,l,Math.min(tm, r));
		node1 b=ask(v*2+1,tm+1,tr,Math.max(tm+1, l),r);
		return merge(a,b);
	}
	static node1 merge(node1 a,node1 b)
	{
		long s=0;
		long l1=a.L,r1=a.R,c1=a.cnt;
		long l2=b.L,r2=b.R,c2=b.cnt;
		long g=GCD(l2,r1); s=c1+c2;
		if(g==1)
		{
			s--;
			g=(l2*r1)/g;
			if(c1==1)
			{
				l1=g;
			}
			if(c2==1)r2=g;
			return new node1(l1,r2,s,true);
		}
		return new node1(l1,r2,s,a.leaf^b.leaf);
	}
	static long f(long l,long r,long a,long b,long N)
	{
		while(r-l>1)
		{
			long m=(l+r)/2;
			long x=m*b;
			if(N<x)
			{
				r=m;
				continue;
			}
			if((N-x)%a==0)r=m;
			else l=m;

		}
		return r;
	}
	static long f1(long a,long A[],long bits[],long sum)
	{
		long s=A.length;
		s=mul(s,a);
		s=(s+(sum%mod))%mod;
		long p=1L;
		for(long x:bits)
		{
			if((a&p)!=0)s=((s-mul(x,p))+mod)%mod;
			p<<=1;
		}
		return s;
	}
	static long f2(long a,long A[],long bits[])
	{
		long s=0;
		long p=1L;
		for(long x:bits)
		{
			if((a&p)!=0)
			{
				s=(s+mul(p,x))%mod;
			}
			p<<=1;
		}
		return s;
	}
	static long f(long x1,long y1,long x2,long y2)
	{
		return Math.abs(x1-x2)+Math.abs(y1-y2);
	}
	static long f(long x,long max,long s)
	{
		long l=-1,r=(x/s)+1;
		while(r-l>1)
		{
			long m=(l+r)/2;
			if(x-m*s>max)l=m;
			else r=m;
		}
		return l+1;
	}
	static int f(long A[],long x)
	{
		int l=-1,r=A.length;
		while(r-l>1)
		{
			int m=(l+r)/2;
			if(A[m]>=x)r=m;
			else l=m;			
		}
		return r;
	}



	static int bin(int x,ArrayList<Integer> A)
	{
		int l=0,r=A.size()-1;
		while(l<=r)
		{
			int m=(l+r)/2;
			int a=A.get(m);
			if(a==x)return m;
			if(a<x)l=m+1;
			else r=m-1;
		}
		return 0;
	}
	static int left(int x,ArrayList<Integer> A)
	{
		int l=-1,r=A.size();
		while(r-l>1)
		{
			int m=(l+r)/2;
			int a=A.get(m);
			if(a<=x)l=m;
			else r=m;
		}
		return l;
	}
	static int right(int x,ArrayList<Integer> A)
	{
		int l=-1,r=A.size();
		while(r-l>1)
		{
			int m=(l+r)/2;
			int a=A.get(m);
			if(a<x)l=m;
			else r=m;
		}
		return r;
	}



	static boolean equal(long A[],long B[])
	{
		for(int i=0; i<A.length; i++)if(A[i]!=B[i])return false;
		return true;	
	}


	static int max(int a ,int b,int c,int d)
	{
		a=Math.max(a, b);
		c=Math.max(c,d);
		return Math.max(a, c);
	}
	static int min(int a ,int b,int c,int d)
	{
		a=Math.min(a, b);
		c=Math.min(c,d);
		return Math.min(a, c);
	}



	static HashMap<Integer,Integer> Hash(int A[])
	{
		HashMap<Integer,Integer> mp=new HashMap<>();
		for(int a:A)
		{
			int f=mp.getOrDefault(a,0)+1;
			mp.put(a, f);
		}
		return mp;
	}
	static long mul(long a, long b)
	{
		return ( a %mod * 1L * b%mod )%mod;
	}
	static void swap(int A[],int a,int b)
	{
		int t=A[a];
		A[a]=A[b];
		A[b]=t;
	}


	static int find(int a)
	{
		if(par[a]<0)return a;
		return par[a]=find(par[a]);
	}
	static void union(int a,int b)
	{
		a=find(a);
		b=find(b);
		if(a!=b)
		{
			par[a]+=par[b];
			par[b]=a;
		}
	}
	static boolean isSorted(int A[])
	{
		for(int i=1; i<A.length; i++)
		{
			if(A[i]<A[i-1])return false;
		}
		return true;
	}

	static boolean isDivisible(StringBuilder X,int i,long num)
	{
		long r=0;
		for(; i<X.length(); i++)
		{
			r=r*10+(X.charAt(i)-'0');
			r=r%num;
		}
		return r==0;
	}    



	static int lower_Bound(int A[],int low,int high, int x) 
	{ 
		if (low > high) 
			if (x >= A[high]) 
				return A[high]; 

		int mid = (low + high) / 2; 

		if (A[mid] == x) 
			return A[mid]; 

		if (mid > 0 && A[mid - 1] <= x && x < A[mid]) 
			return A[mid - 1]; 

		if (x < A[mid]) 
			return lower_Bound( A, low, mid - 1, x); 

		return lower_Bound(A, mid + 1, high, x); 
	} 

	static String f(String A)
	{
		String X="";
		for(int i=A.length()-1; i>=0; i--)
		{
			int c=A.charAt(i)-'0';
			X+=(c+1)%2;
		}
		return X;
	}

	static void sort(long[] a) //check for long
	{
		ArrayList<Long> l=new ArrayList<>();
		for (long i:a) l.add(i);
		Collections.sort(l);
		for (int i=0; i<a.length; i++) a[i]=l.get(i);
	}

	static String swap(String X,int i,int j)
	{
		char ch[]=X.toCharArray();
		char a=ch[i];
		ch[i]=ch[j];
		ch[j]=a;
		return new String(ch);
	}

	static int sD(long n)  
	{  

		if (n % 2 == 0 )  
			return 2;  

		for (int i = 3; i * i <= n; i += 2) {  
			if (n % i == 0 )  
				return i;  
		}  

		return (int)n;  
	}  

	static void setGraph(int N)
	{
		tot=new int[N+1];
		partial=new int[N+1];
		D=new int[N+1];
		P=new int[N+1][(int)(Math.log(N)+10)];
		set=new boolean[N+1];
		g=new ArrayList<ArrayList<Integer>>();
		for(int i=0; i<=N; i++)
		{

			g.add(new ArrayList<>());		
			D[i]=Integer.MAX_VALUE;
			//D2[i]=INF;
		}
	}



	static  long pow(long a,long b)
	{
		//long mod=1000000007;
		long pow=1;
		long x=a;
		while(b!=0)
		{
			if((b&1)!=0)pow=(pow*x)%mod;
			x=(x*x)%mod;
			b/=2;
		}
		return pow;
	}

	static long toggleBits(long x)//one's complement || Toggle bits
	{
		int n=(int)(Math.floor(Math.log(x)/Math.log(2)))+1;

		return ((1<<n)-1)^x;
	}

	static int countBits(long a)
	{
		return (int)(Math.log(a)/Math.log(2)+1);
	}

	static long fact(long N)
	{ 
		long n=2; 
		if(N<=1)return 1;
		else
		{
			for(int i=3; i<=N; i++)n=(n*i)%mod;
		}
		return n;
	}

	static int kadane(int A[])
	{
		int lsum=A[0],gsum=A[0];
		for(int i=1; i<A.length; i++)
		{
			lsum=Math.max(lsum+A[i],A[i]);
			gsum=Math.max(gsum,lsum);
		}
		return gsum;
	}

	static void sort(int[] a) {
		ArrayList<Integer> l=new ArrayList<>();
		for (int i:a) l.add(i);
		Collections.sort(l);
		for (int i=0; i<a.length; i++) a[i]=l.get(i);
	}

	static boolean isPrime(long N)
	{
		if (N<=1)  return false; 
		if (N<=3)  return true; 
		if (N%2 == 0 || N%3 == 0) return false; 
		for (int i=5; i*i<=N; i=i+6) 
			if (N%i == 0 || N%(i+2) == 0) 
				return false; 
		return true; 
	}
	static void print(char A[])
	{
		for(char c:A)System.out.print(c+" ");
		System.out.println();
	}
	static void print(boolean A[])
	{
		for(boolean c:A)System.out.print(c+" ");
		System.out.println();
	}
	static void print(int A[])
	{
		for(int a:A)System.out.print(a+" ");
		System.out.println();	
	}
	static void print(long A[])
	{
		for(long i:A)System.out.print(i+ " ");
		System.out.println();

	}
	static void print(ArrayList<Integer> A)
	{
		for(int a:A)System.out.print(a+" ");
		System.out.println();
	}

	static int i()
	{
		return in.nextInt();
	}

	static long l()
	{
		return in.nextLong();
	}

	static int[] input(int N){
		int A[]=new int[N];
		for(int i=0; i<N; i++)
		{
			A[i]=in.nextInt();
		}
		return A;
	}

	static long[] inputLong(int N)     {
		long A[]=new long[N];
		for(int i=0; i<A.length; i++)A[i]=in.nextLong();
		return A;
	}

	static long GCD(long a,long b) 
	{
		if(b==0)
		{
			return a;
		}
		else return GCD(b,a%b );
	}

}
class node1
{
	long L,R,cnt;
	boolean leaf;
	node1(long l,long r,long c,boolean x)
	{
		this.leaf=x;
		this.L=l;
		this.R=r;
		this.cnt=c;
	}
}


//Code For FastReader
//Code For FastReader
//Code For FastReader
//Code For FastReader
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;
	}

}