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

const int MAXN = 500005;

int N, M, K;
vector<int> g[MAXN], rg[MAXN];
int comp[MAXN];
vector<int> order;
int num_scc = 0;

void dfs1(int start) {
    stack<pair<int,int>> st;
    st.push({start, 0});
    comp[start] = -2;
    while (!st.empty()) {
        auto &top = st.top();
        int v = top.first, &i = top.second;
        if (i < (int)g[v].size()) {
            int u = g[v][i++];
            if (comp[u] == -1) {
                comp[u] = -2;
                st.push({u, 0});
            }
        } else {
            order.push_back(v);
            st.pop();
        }
    }
}

void dfs2(int start, int c) {
    stack<int> st;
    st.push(start);
    comp[start] = c;
    while (!st.empty()) {
        int v = st.top(); st.pop();
        for (int u : rg[v]) {
            if (comp[u] == -2) {
                comp[u] = c;
                st.push(u);
            }
        }
    }
}

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

    cin >> N >> M >> K;

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

    fill(comp + 1, comp + N + 1, -1);

    for (int i = 1; i <= N; i++) {
        if (comp[i] == -1) dfs1(i);
    }

    for (int i = (int)order.size() - 1; i >= 0; i--) {
        if (comp[order[i]] == -2) {
            dfs2(order[i], num_scc++);
        }
    }

    vector<bool> reach(N + 1, false);
    queue<int> q;
    reach[1] = true;
    q.push(1);

    while (!q.empty()) {
        int v = q.front(); q.pop();
        for (int u : g[v]) {
            if (!reach[u]) {
                reach[u] = true;
                q.push(u);
            }
        }
    }

    for (int i = 1; i <= N; i++) {
        if (!reach[i]) {
            cout << "No\n";
            return 0;
        }
    }

    vector<vector<int>> sccs(num_scc);
    for (int i = 1; i <= N; i++) {
        sccs[comp[i]].push_back(i);
    }

    vector<int> scc_gcd(num_scc, 0);
    vector<int> dist(N + 1, -1);

    for (int c = 0; c < num_scc; c++) {
        queue<int> q;
        int root = sccs[c][0];

        for (int v : sccs[c]) dist[v] = -1;

        dist[root] = 0;
        q.push(root);

        while (!q.empty()) {
            int v = q.front(); q.pop();
            for (int u : g[v]) {
                if (comp[u] != c) continue;
                if (dist[u] == -1) {
                    dist[u] = dist[v] + 1;
                    q.push(u);
                } else {
                    int cycle_len = dist[v] + 1 - dist[u];
                    scc_gcd[c] = gcd(scc_gcd[c], abs(cycle_len));
                }
            }
        }
    }

    for (int c = 0; c < num_scc; c++) {
        if (scc_gcd[c] == 0 || scc_gcd[c] % 2 == 0) {
            cout << "No\n";
            return 0;
        }
    }

    cout << "Yes\n";
    return 0;
}