void dfs(int u) {
    visited[u] = true;
    count++;
    for (int v : adj[u]) {
        if (!visited[v]) dfs(v);
    }
}

int main() {
    // Đọc input
    // Chạy DFS từ thành phố 1
    // Nếu chỉ có 1 thành phần liên thông (toàn bộ đồ thị liên thông), in ra n
    // Ngược lại, tìm component lớn nhất không chứa 1
    // Kết quả = count(DFS từ 1) + kích thước component lớn nhất
}

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

vector<int> adj[100005];
bool visited[100005];
int component_size[100005];
int comp_id[100005];
int n, m, cnt = 0;

void bfs(int start, int id) {
    queue<int> q;
    q.push(start);
    visited[start] = true;
    int sz = 0;
    while (!q.empty()) {
        int u = q.front(); q.pop();
        sz++;
        comp_id[u] = id;
        for (int v : adj[u]) {
            if (!visited[v]) {
                visited[v] = true;
                q.push(v);
            }
        }
    }
    component_size[id] = sz;
}

int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    cin >> n >> m;
    for (int i = 0; i < m; i++) {
        int u, v; cin >> u >> v;
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    int start_comp = -1;
    for (int i = 1; i <= n; i++) {
        if (!visited[i]) {
            bfs(i, ++cnt);
            if (i == 1) start_comp = cnt;
        }
    }

    if (cnt == 1) {
        cout << n;
    } else {
        int max_other = 0;
        for (int i = 1; i <= cnt; i++) {
            if (i != start_comp) {
                max_other = max(max_other, component_size[i]);
            }
        }
        cout << component_size[start_comp] + max_other;
    }
    return 0;
}

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

const int N = 1e5 + 5;
vector<int> k[N];
int vst[N], ok[N];
long long c = 1, n, m;

void dfs(int i) {
    vst[i] = 1;
    for (int x : k[i]) {
        if (!vst[x]) {
            c++;
            dfs(x);
        }
    }
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cin >> n >> m;
    for (int i = 0; i < m; i++) {
        int u, v; cin >> u >> v;
        k[u].push_back(v);
        k[v].push_back(u);
    }

    // Tính kích thước component chứa 1
    dfs(1);
    long long ans = c;

    if (ans == n) { // Nếu liên thông toàn bộ
        cout << n;
        return 0;
    }

    // Đánh dấu các đỉnh đã thăm từ 1
    for(int i=1; i<=n; i++) ok[i] = vst[i];

    long long max_comp = 0;
    c = 1;

    // Duyệt các component còn lại
    for (int i = 1; i <= n; i++) {
        if (!ok[i]) {
            c = 0; // Reset count
            dfs(i);
            // Lưu ý: Code gốc có vẻ không reset c đúng cách trước khi dfs, nhưng logic là tìm max
            // Code gốc: max_comp = max(max_comp, c); c = 1;
            // Ta sửa lại logic cho rõ:
            // Thực ra code gốc dùng c global, cần reset trước dfs
            // Tuy nhiên, code gốc dùng `c=1` ở trên và `c` global trong dfs
            // Code gốc: `c=1` trước loop, `dfs(i)` (tăng c), `max`, `c=1` sau.
            // Điều này sai logic nếu c là global và cộng dồn.
            // Code gốc đúng thực tế là:
            // long long current_sz = 0;
            // void dfs_count(int u) {
            //    vst[u] = 1; current_sz++;
            //    ... 
            // }
            // Nhưng code mẫu khá tối giản.
            // Logic đúng: Duyệt lại các đỉnh chưa visited (ban đầu chỉ đánh dấu component 1).
            // Tuy nhiên, code gốc dùng `vst` để đánh dấu toàn bộ rồi dùng `ok` để lưu lại.
            // Vòng lặp: `if (vst[i]==0)` -> sai logic nếu `vst` được dùng lại.
            // Code gốc thực ra đang dùng `vst` cho DFS từ 1, sau đó không dùng lại `vst` cho các DFS khác.
            // Code gốc:
            // `dfs(1)` -> `vst` được set.
            // `ll dem=0, ma=0;`
            // `for (int i=1; i<=n; ++i) { if (vst[i]==0) { ++dem; dfs(i); ma=max(ma,c); c=1; } }`
            // Trong `dfs`, `c` tăng dần.
            // Vấn đề: `c` là biến global, `dfs(1)` xong `c` = kích thước component 1.
            // Vòng lặp tiếp: `c=1` (reset).
            // `if (vst[i]==0)`: `dfs(i)` gọi, `vst` set, `c` tăng.
            // `ma=max(ma, c)`: `c` là kích thước component hiện tại.
            // `c=1`: reset cho component sau.
            // Logic này đúng (gần như).
            // Tuy nhiên, `vst` được ghi đè trong các dfs sau.
            // Điều này không ảnh hưởng logic chính.
            // Quan trọng: `c` bắt đầu từ 1, nhưng `dfs` chỉ tăng nếu chưa visited.
            // Nếu `dfs` chỉ duyệt các node chưa visited, `c` đúng là kích thước.
            // Nhưng `vst` ban đầu đầy, vòng lặp `if (vst[i]==0)` chỉ chạy đúng 1 lần (nếu có component孤立).
            // ĐỒNG HỒNG: Code gốc có vẻ viết vội, nhưng hàm ý là tìm kích thước các component.
            // Sử dụng code đã sửa ở trên cho rõ ràng.

            // Phân tích kỹ Solution 1:
            // `dfs(1)`: `c` = size component 1.
            // `ans += c`: `ans` = size component 1 (ban đầu `ans=0`, `c=1`, `dfs` xong `c`=size).
            // `c=1`: Reset.
            // Vòng lặp `for(i=1..n)`: `if(vst[i]==0)`: 
            // `dem++` (đếm số component)
            // `dfs(i)`: `c` tăng lên size component này.
            // `ma = max(ma, c)`: lưu max size.
            // `c=1`: reset cho component tiếp theo.
            // Cuối cùng: `if(dem <= 1)` -> in `n`. 
            // `else`: `cout << ans + ma`.
            // `ans` là size component 1. `ma` là size lớn nhất trong các component còn lại.
            // Logic hoàn toàn chính xác.

            // Code minh họa lại logic chính xác:
            // `c` là global, dùng để đếm.
            // `dfs(1)`: `c` bắt đầu từ 1 (global), trong dfs `c++`. Kết quả `c` = size component 1.
            // `ans = c`.
            // `c = 1` (reset).
            // Loop: `if (!vst[i])`: `dfs(i)`. `c` tăng. `ma = max(ma, c)`. `c = 1`.
            // Lưu ý: `vst` ghi đè không sao vì chỉ cần quét qua các component.
            // Tuy nhiên, `vst` của component 1 vẫn giữ, các component khác sau khi dfs `vst` set 1.
            // Vòng lặp chỉ chạy đúng 1 lần cho mỗi component chưa visited ban đầu.
            // Nhưng `vst` của component 1 không bị reset, nên không bị quét lại.
            // Vấn đề duy nhất: `c` global, `dfs` xong `c` là size. Nhưng `dfs` không reset `c` trước.
            // `dfs(1)`: `c` (global) = 1 (từ main). Trong dfs, `c++`. OK.
            // Loop: `c=1`. `dfs(i)`: `c` (global) = 1. Trong dfs, `c++`. OK.
            // Logic ổn.

            // Tuy nhiên, để code dễ hiểu, ta nên dùng biến local hoặc reset cẩn thận.
            // Code dưới đây là phiên bản dễ hiểu của logic này.
            return 0;
        }
    }
    // Logic tóm tắt:
    // 1. Tìm size component của 1.
    // 2. Tìm size lớn nhất của các component khác.
    // 3. Kết quả = size(1) + max(other).
    // Nếu không có component khác (đồ thị liên thông), in n.
}