#include <bits/stdc++.h>

#define IO	       { ios_base::sync_with_stdio(false); cin.tie(0); }

using namespace std;


int lim;
int n, m;
vector<vector<int>> adj;
vector<int> subtree_size;
vector<bool> is_removed;
vector<int> ans;

int get_subtree_size(int node, int parent = -1) {
	subtree_size[node] = 1;
	for (int child : adj[node]) {
		if (child == parent || is_removed[child]) { continue; }
		subtree_size[node] += get_subtree_size(child, node);
	}
	return subtree_size[node];
}

int get_centroid(int node, int tree_size, int parent = -1) {
	for (int child : adj[node]) {
		if (child == parent || is_removed[child]) { continue; }
		if (subtree_size[child] * 2 > tree_size) {
			return get_centroid(child, tree_size, node);
		}
	}
	return node;
}

void build_centroid_decomp(int node = 0) {
    int sz = get_subtree_size(node);
    if (sz <= lim) return;
	int centroid = get_centroid(node, sz);

	ans.push_back(centroid);

	is_removed[centroid] = true;

	for (int child : adj[centroid]) {
		if (is_removed[child]) { continue; }
		build_centroid_decomp(child);
	}
}


vector<vector<int>> adj2;
vector<bool> vis;

void dfs(int node) {
    vis[node] = 1;
    for (int v: adj2[node]) {
        if (!vis[v]) {
            adj[v].push_back(node);
            adj[node].push_back(v);
            dfs(v);
        }
    }
}

void solve() {
    cin >> n >> m;
    for (int i=1; ;i++) {
        if (i*i >= n) {
            lim = i;
            break;
        }
    }
    
    adj.clear();
    adj2.clear();
    adj.resize(n+100);
    adj2.resize(n+100);
    subtree_size.assign(n+100, 0);
    vis.assign(n+100, 0);
    is_removed.assign(n+100, 0);

	for (int i = 0; i < m; i++) {
		int a, b;
		cin >> a >> b;
		a--;
		b--;
        adj2[a].push_back(b);
        adj2[b].push_back(a);
	}

    dfs(0);
    ans.clear();

    build_centroid_decomp(0);

    assert(ans.size() <= lim);

    vector<int> gg(n + 1);
    queue<int> q;
    for(auto x: ans) {
        gg[x] = 1;
        q.push(x);
    }
    while(!q.empty()) {
        int temp = q.front();
        assert(gg[temp] - 1 <= lim);
        q.pop();
        for(auto x: adj[temp]) {
            if(gg[x] == 0) {
                gg[x] = gg[temp] + 1;
                q.push(x);
            }
        }
    }

    cout << ans.size() << endl;
    
    for (int x: ans) {
        cout << x + 1 << " ";
    }
    cout << endl;
}

int main() {
    IO;
    int t;
    cin >> t;
    while(t--) {
        solve();
    }
}
/*
2
4 3
1 2
2 3
3 4
6 7
1 2
2 3
3 1
1 4
4 5
5 6
6 4

*/