#include <bits/stdc++.h>
using namespace std;

const int kNmax = 100005;

class Task {
public:
	void solve() {
		read_input();
		print_output(get_result());
	}

private:
	int n;
	int m;
	vector<int> adj[kNmax];
	vector<int> idx;
	vector<int> lowlink;
	int index;
	stack<int> S;
	vector<int> in_stack;
	void read_input() {
		ifstream fin("ctc.in");
		fin >> n >> m;
		for (int i = 1, x, y; i <= m; i++) {
			fin >> x >> y;
			adj[x].push_back(y);
			adj[y].push_back(x);
		}
		idx.resize(n);
		lowlink.resize(n);
		in_stack.resize(n);
		idx.assign(n, -1);
		in_stack.assign(n, 0);
		fin.close();
	}

	void ctc_tarjan(vector<int> sol) {
		for (int i = 1; i <= n; ++i) {
			if (idx[i] == -1) { // daca idx[it] nu e definit
				tarjan(i, sol);
			}
		}
	}

	void tarjan(int node, vector<int> sol) {
		idx[node] = index;
		lowlink[node] = index;
		index++;
		S.push(node);
		in_stack[node] = 1;

		for (auto it : adj[node]) {
			if (idx[it] == -1) { // daca idx[it] nu e definit
				tarjan(it, sol);
				lowlink[node] = min(lowlink[node], lowlink[it]);
			} else if (in_stack[it]) {
				lowlink[node] = min(lowlink[node], idx[it]);
			}
		}
		if (lowlink[node] == idx[node]) {
			int n;
			do {
				n = S.top();
				S.pop();
				sol.push_back(n);
				in_stack[n] = 0;
			} while (node != n);
		}
	}

	vector<int> get_result() {
		/*
		TODO: Gasiti nodurile critice ale grafului neorientat stocat cu liste
		de adiacenta in adj.
		*/
		vector<int> sol;
		ctc_tarjan(sol);
		return sol;
	}

	void print_output(const vector<int>& result) {
		ofstream fout("ctc.out");
		for (int i = 0; i < int(result.size()); i++) {
			fout << result[i] << ' ';
		}
		fout << '\n';
		fout.close();
	}
};

// Please always keep this simple main function!
int main() {
	// Allocate a Task object on heap in order to be able to
	// declare huge static-allocated data structures inside the class.
	Task *task = new Task();
	task->solve();
	delete task;
	return 0;
}