#include <bits/stdc++.h>

using namespace std;

vector< vector<int> > graph;
vector<int> depth;
vector<int> max_component_size;
vector<int> rest;

void dfs(int v, int parent, int &distance_to_earliest_parent, int &component_size) {
    depth[v] = (parent == -1) ? 0: depth[parent] + 1;
    distance_to_earliest_parent = 0;
    component_size = 1;
    for (int u: graph[v]) {
        if (u != parent) {
            int d, vertex;
            if (depth[u] != -1) {
                d = depth[v] - depth[u];
            } else {
                dfs(u, v, d, vertex);
                d--;
                if (d <= 0) {
                    max_component_size[v] = max(max_component_size[v], vertex);
                    rest[v] -= vertex;
                }
                component_size += vertex;
            }
            distance_to_earliest_parent = max(distance_to_earliest_parent, d);
        }
    }
}

int main() {
    ios_base::sync_with_stdio(false);

    int n, m;
    cin >> n >> m;

    graph.assign(n, vector<int>());
    depth.assign(n, -1);
    max_component_size.assign(n, 0);
    rest.assign(n, n - 1);

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

    int garbage;
    dfs(0, -1, garbage, garbage);

    int dragon = 0;
    int max_number = n;
    for (int i = 0; i < n; i++) {
        int number = max(max_component_size[i], rest[i]);
        if (number < max_number) {
            max_number = number;
            dragon = i;
        }
    }

    cout << dragon + 1 << endl;
}