#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
//
//struct segtree {
//    ll n;
//    vector<ll> t;
//
//    segtree() {}
//
//    segtree(vector<ll>& in) {
//        n = in.size();
//        t.resize(4 * n);
//        build(0, 0, n - 1, in);
//    }
//
//    void build(ll v, ll tl, ll tr, vector<ll>& in) {
//        if (tl == tr) {
//            t[v] = in[tl];
//            return;
//        }
//        ll tm = (tl + tr) / 2;
//        build(2 * v + 1, tl, tm, in);
//        build(2 * v + 2, tm + 1, tr, in);
//        t[v] = t[2 * v + 1] + t[2 * v + 2];
//    }
//
//    ll get(ll v, ll tl, ll tr, ll l, ll r) {
//        if (l <= tl && tr <= r) {
//            return t[v];
//        }
//        if (tr < l || r < tl) {
//            return 0;
//        }
//        ll tm = (tl + tr) / 2;
//        return get(2 * v + 1, tl, tm, l, r) + get(2 * v + 2, tm + 1, tr, l, r);
//    }
//
//    void upd(ll val, ll idx, ll v, ll tl, ll tr) {
//        if (tl == idx && idx == tr) {
//            t[v] = val;
//            return;
//        }
//        if (tr < idx || idx < tl) {
//            return;
//        }
//        ll tm = (tl + tr) / 2;
//        upd(val, idx, 2 * v + 1, tl, tm);
//        upd(val, idx, 2 * v + 2, tm + 1, tr);
//        t[v] = t[2 * v + 1] + t[2 * v + 2];
//    }
//
//    ll get(ll l, ll r) {
//        return get(0, 0, n - 1, l, r);
//    }
//
//    void upd(ll val, ll idx) {
//        upd(val, idx, 0, 0, n - 1);
//    }
//};
//

// C
//const ll INF = 1e18;
//
//void solve() {
//    ll n, m; cin >> n >> m;
//    vector<ll> a(n);
//    for (int i = 0; i < n; i++) cin >> a[i];
//    vector<ll> b(n);
//    for (int i = 0; i < n; i++) cin >> b[i];
//    vector<ll> c(m);
//    for (int i = 0; i < m; i++) cin >> c[i];
//    vector<pair<ll, ll>> evs;
//    for (int i = 0; i < n; i++) {
//        evs.push_back({a[i], 0});
//    }
//    for (int i = 0; i < m; i++) {
//        evs.push_back({c[i], 1});
//    }
//    sort(evs.begin(), evs.end());
//    vector<ll> ord;
//    for (int i = 0; i < evs.size(); i++) {
//        if (evs[i].second == 0) {
//            ord.push_back(i % 2);
//        }
//    }
//
//}
//
//int main() {
//    ios_base::sync_with_stdio(false); cin.tie(0);
//
//    ll tst = 1;
//    while (tst--) {
//        solve();
//    }
//}


//const ll INF = 1e18;
//const ll N = 2005;
//
//vector<ll> g[N], rev[N];
//bool used[N];
//bool reach[N][N];
//
//void dfs_reach(ll v, ll root) {
//    reach[root][v] = true;
//    used[v] = true;
//    for (auto to : g[v]) {
//        if (!used[to]) {
//            dfs_reach(to, root);
//        }
//    }
//}
//
//vector<ll> top;
//void dfs_top(ll v) {
//    used[v] = true;
//    for (auto to : g[v]) {
//        if (!used[to]) {
//            dfs_top(to);
//        }
//    }
//    top.push_back(v);
//}
//
//void solve() {
//    ll n, m, G; cin >> n >> m >> G;
//    for (int i = 0; i < m; i++) {
//        ll u, v; cin >> u >> v;
//        u--; v--;
//        g[u].push_back(v);
//        rev[v].push_back(u);
//    }
//    for (int v = 0; v < n; v++) {
//        for (int i = 0; i < n; i++) {
//            used[i] = false;
//        }
//        dfs_reach(v, v);
//    }
//    for (int i = 0; i < n; i++) {
//        used[i] = false;
//    }
//    for (int i = 0; i < n; i++) {
//        if (!used[i]) {
//            dfs_top(i);
//        }
//    }
////    reverse(top.begin(), top.end());
////    for (auto v : top) {
////        cout << v + 1 << " ";
////    }
////    cout << '\n';
//    vector<ll> num(n);
//    for (int i = 0; i < n; i++) {
//        num[top[i]] = i;
//    }
//    ll need = 0;
//    for (int v = n - 1; v >= 0; v--) {
//        vector<pair<ll, ll>> vs;
//        for (auto to : rev[v]) {
//            vs.push_back({to, to});
//        }
//        sort(vs.begin(), vs.end());
//        for (int i = 0; i < vs.size(); i++) {
//            bool plus = true;
//            for (int j = i - 1; j >= 0; j--) {
//                if (reach[vs[j].second][vs[i].second]) {
//                    plus = false;
//                    break;
//                }
//            }
//            need += plus;
//        }
//    }
//    cout << m - need << '\n';
//    cout << 1 << '\n';
//}

const ll INF = 1e18;
const ll N = 2005;

vector<pair<ll, ll>> g[N];
bool used[N];

void dfs_reach(ll v, ll block) {
    used[v] = true;
    for (auto [to, e] : g[v]) {
        if (e == block) continue;
        if (!used[to]) {
            dfs_reach(to, block);
        }
    }
}


void solve() {
    ll n, m, G; cin >> n >> m >> G;
    vector<pair<ll, ll>> es;
    for (int i = 0; i < m; i++) {
        ll u, v; cin >> u >> v;
        u--; v--;
        g[u].push_back({v, i});
        es.push_back({u, v});
    }
    ll need = 0;
    for (int e = 0; e < m; e++) {
        for (int i = 0; i < n; i++) {
            used[i] = false;
        }
        ll u = es[e].first, v = es[e].second;
        dfs_reach(u, e);
        need += used[v];
    }
    cout << need << '\n';
    cout << 1 << '\n';
}


int main() {
    ios_base::sync_with_stdio(false); cin.tie(0);

    ll tst = 1;
    while (tst--) {
        solve();
    }
}