#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#include <algorithm>
#include <functional>

using namespace std;
typedef long long ll;

class Node {
public:
    int id;
    int dist;
    Node(int v, int d) : id(v), dist(d) {}
    Node() {}
    friend bool operator>(const Node& A, const Node& B) { return (A.dist > B.dist); }
};

void add_edge(int u, int v);
void bfs(int st);

const int INF = 0x3f3f3f3f;
const int MAX = 3005;
vector<int> graph[MAX];
bool visited[MAX];
int dist[MAX][MAX];
vector<Node> dist_from[MAX], dist_to[MAX];

int main() {
    // freopen("test.txt", "r", stdin);
    int n, m;
    while (scanf("%d %d", &n, &m) != EOF) {
        // 初始化
        for (int i = 0; i < MAX; i++) {
            graph[i].clear();
            dist_from[i].clear();
            dist_to[i].clear();
        }
        memset(dist, INF, sizeof(dist));
        // 输入
        int u, v;
        while (m--) {
            scanf("%d %d", &u, &v);
            add_edge(u, v);
        }
        // BFS
        for (int u = 1; u <= n; u++) {
            bfs(u);
        }
        // 预处理
        for (int u = 1; u <= n; u++)
            for (int v = 1; v <= n; v++) {
                if (u == v) {
                    continue;
                }
                if (dist[u][v] != INF)
                    dist_from[u].push_back(Node(v, dist[u][v]));
                if (dist[v][u] != INF)
                    dist_to[u].push_back(Node(v, dist[v][u]));
            }
        for (int u = 1; u <= n; u++) {
            sort(dist_from[u].begin(), dist_from[u].end(), greater<Node>());
            sort(dist_to[u].begin(), dist_to[u].end(), greater<Node>());
        }
        // 求解
        int res = 0;
        int A, B, C, D;
        for (int b = 1; b <= n; b++)
            for (int c = 1; c <= n; c++) {
                if (b == c || dist[b][c] == INF) {
                    continue;
                }
                for (int i = 0; i < min(3, (int)dist_to[b].size()); i++) {
                    int a = dist_to[b][i].id;
                    if (a == b || a == c) {
                        continue;
                    }
                    for (int j = 0; j < min(3, (int)dist_from[c].size()); j++) {
                        int d = dist_from[c][j].id;
                        if (d == a || d == b || d == c) {
                            continue;
                        }
                        int sum = dist[a][b] + dist[b][c] + dist[c][d];
                        if (res < sum) {
                            res = sum;
                            A = a;
                            B = b;
                            C = c;
                            D = d;
                        }
                    }
                }
            }
        // 输出
        // printf("%d %d %d %d\n", A, B, C, D);
        printf("%d %d\n", res, B);
    }
    return 0;
}

// 加入新边
inline void add_edge(int u, int v) { graph[u].push_back(v); }
// 广度优先搜索
void bfs(int st) {
    memset(visited, false, sizeof(visited));
    queue<int> q;
    q.push(st);
    visited[st] = true;
    dist[st][st] = 0;
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        for (int i = 0; i < graph[u].size(); i++) {
            int v = graph[u][i];
            if (!visited[v]) {
                q.push(v);
                visited[v] = true;
                dist[st][v] = dist[st][u] + 1;
            }
        }
    }
}