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

using ll = long long;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int N, M;
    long long K;
    cin >> N >> M >> K;

    vector<vector<int>> g(N), rg(N);
    vector<pair<int,int>> edges;
    edges.reserve(M);

    for (int i = 0; i < M; i++) {
        int u, v;
        cin >> u >> v;
        --u; --v;
        g[u].push_back(v);
        rg[v].push_back(u);
        edges.push_back({u, v});
    }

    // Kosaraju
    vector<int> used(N, 0), order;
    order.reserve(N);

    for (int s = 0; s < N; s++) {
        if (used[s]) continue;
        // iterative DFS for postorder
        stack<pair<int,int>> st;
        st.push({s, 0});
        used[s] = 1;
        while (!st.empty()) {
            auto &[v, idx] = st.top();
            if (idx < (int)g[v].size()) {
                int to = g[v][idx++];
                if (!used[to]) {
                    used[to] = 1;
                    st.push({to, 0});
                }
            } else {
                order.push_back(v);
                st.pop();
            }
        }
    }

    vector<int> comp(N, -1);
    int C = 0;
    vector<vector<int>> members;

    for (int i = N - 1; i >= 0; i--) {
        int s = order[i];
        if (comp[s] != -1) continue;
        comp[s] = C;
        members.push_back({});
        stack<int> st;
        st.push(s);
        while (!st.empty()) {
            int v = st.top(); st.pop();
            members[C].push_back(v);
            for (int to : rg[v]) {
                if (comp[to] == -1) {
                    comp[to] = C;
                    st.push(to);
                }
            }
        }
        C++;
    }

    // vertices in each SCC
    vector<int> sz(C, 0);
    for (int v = 0; v < N; v++) sz[comp[v]]++;

    // internal graph per SCC for gcd check
    vector<vector<pair<int,int>>> internal_edges(C);
    vector<vector<int>> dag(C);
    vector<int> indeg(C, 0);

    for (auto [u, v] : edges) {
        int cu = comp[u], cv = comp[v];
        if (cu == cv) {
            internal_edges[cu].push_back({u, v});
        } else {
            dag[cu].push_back(cv);
        }
    }

    // dedup DAG edges
    for (int c = 0; c < C; c++) {
        sort(dag[c].begin(), dag[c].end());
        dag[c].erase(unique(dag[c].begin(), dag[c].end()), dag[c].end());
        for (int to : dag[c]) indeg[to]++;
    }

    // Build node list per SCC for quick membership
    vector<vector<int>> nodes_of_comp = members;

    // Check each SCC is "good":
    //  - size >= 2
    //  - gcd of cycle lengths is odd
    vector<char> good(C, true);

    // adjacency only inside each SCC
    vector<vector<int>> in_adj(N);
    for (auto [u, v] : edges) {
        if (comp[u] == comp[v]) in_adj[u].push_back(v);
    }

    vector<int> seen(N, 0);
    vector<ll> dist(N, 0);

    for (int c = 0; c < C; c++) {
        if (sz[c] == 1) {
            good[c] = false; // self-loop does not exist by constraint
            continue;
        }

        // DFS inside SCC to assign dist
        int root = nodes_of_comp[c][0];
        stack<int> st;
        st.push(root);
        seen[root] = 1;
        dist[root] = 0;

        while (!st.empty()) {
            int v = st.top(); st.pop();
            for (int to : in_adj[v]) {
                if (comp[to] != c) continue;
                if (!seen[to]) {
                    seen[to] = 1;
                    dist[to] = dist[v] + 1;
                    st.push(to);
                }
            }
        }

        ll gg = 0;
        for (auto [u, v] : internal_edges[c]) {
            ll x = dist[u] + 1 - dist[v];
            if (x < 0) x = -x;
            gg = std::gcd(gg, x);
        }

        // clear seen for this SCC
        for (int v : nodes_of_comp[c]) seen[v] = 0;

        if (gg % 2 == 0) good[c] = false;
    }

    for (int c = 0; c < C; c++) {
        if (!good[c]) {
            cout << "No\n";
            return 0;
        }
    }

    // longest path from start SCC in DAG
    int start = comp[0];

    queue<int> q;
    vector<int> topo;
    topo.reserve(C);
    vector<int> indeg2 = indeg;
    for (int c = 0; c < C; c++) {
        if (indeg2[c] == 0) q.push(c);
    }
    while (!q.empty()) {
        int v = q.front(); q.pop();
        topo.push_back(v);
        for (int to : dag[v]) {
            if (--indeg2[to] == 0) q.push(to);
        }
    }

    const int NEG = -1e9;
    vector<int> dp(C, NEG);
    dp[start] = 1;

    for (int v : topo) {
        if (dp[v] < 0) continue;
        for (int to : dag[v]) {
            dp[to] = max(dp[to], dp[v] + 1);
        }
    }

    int best = 0;
    for (int c = 0; c < C; c++) best = max(best, dp[c]);

    cout << (best == C ? "Yes\n" : "No\n");
    return 0;
}