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

const int MAXN = 500005;
int N, M, K;
vector<int> g[MAXN], rg[MAXN];
bool vis[MAXN];
int comp[MAXN], num_scc;
vector<int> order;

void dfs1(int start) {
    stack<pair<int, int>> st;
    st.push({start, 0});
    vis[start] = true;
    
    while (!st.empty()) {
        auto& [v, idx] = st.top();
        if (idx < (int)g[v].size()) {
            int u = g[v][idx++];
            if (!vis[u]) {
                vis[u] = true;
                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] == -1) {
                comp[u] = c;
                st.push(u);
            }
        }
    }
}

bool is_strongly_connected() {
    vector<bool> reachable(N + 1, false);
    queue<int> q;
    reachable[1] = true;
    q.push(1);
    
    while (!q.empty()) {
        int v = q.front();
        q.pop();
        for (int u : g[v]) {
            if (!reachable[u]) {
                reachable[u] = true;
                q.push(u);
            }
        }
    }
    
    for (int i = 1; i <= N; i++) {
        if (!reachable[i]) return false;
    }
    
    vector<bool> reachable_from(N + 1, false);
    reachable_from[1] = true;
    q.push(1);
    
    while (!q.empty()) {
        int v = q.front();
        q.pop();
        for (int u : rg[v]) {
            if (!reachable_from[u]) {
                reachable_from[u] = true;
                q.push(u);
            }
        }
    }
    
    for (int i = 1; i <= N; i++) {
        if (!reachable_from[i]) return false;
    }
    
    return true;
}

int gcd_of_cycle_lengths() {
    vector<int> dist(N + 1, -1);
    int gcd_val = 0;
    
    int target_scc = comp[1];
    
    vector<int> scc_nodes;
    for (int i = 1; i <= N; i++) {
        if (comp[i] == target_scc) {
            scc_nodes.push_back(i);
        }
    }
    
    for (int start : scc_nodes) {
        fill(dist.begin(), dist.end(), -1);
        dist[start] = 0;
        queue<int> q;
        q.push(start);
        
        while (!q.empty()) {
            int v = q.front();
            q.pop();
            for (int u : g[v]) {
                if (comp[u] != target_scc) continue;
                if (dist[u] == -1) {
                    dist[u] = dist[v] + 1;
                    q.push(u);
                } else {
                    int cycle_len = dist[v] + 1 - dist[u];
                    if (cycle_len > 0) {
                        gcd_val = __gcd(gcd_val, cycle_len);
                        if (gcd_val == 1) return 1;
                    }
                }
            }
        }
    }
    
    return gcd_val;
}

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);
    }
    
    if (!is_strongly_connected()) {
        cout << "No\n";
        return 0;
    }
    
    fill(vis + 1, vis + N + 1, false);
    for (int i = 1; i <= N; i++) {
        if (!vis[i]) {
            dfs1(i);
        }
    }
    
    fill(comp + 1, comp + N + 1, -1);
    num_scc = 0;
    for (int i = order.size() - 1; i >= 0; i--) {
        int v = order[i];
        if (comp[v] == -1) {
            dfs2(v, num_scc++);
        }
    }
    
    int cycle_gcd = gcd_of_cycle_lengths();
    
    if (cycle_gcd == 1) {
        cout << "Yes\n";
    } else {
        if (cycle_gcd == 0) {
            cout << "No\n";
        } else {
            cout << "No\n";
        }
    }
    
    return 0;
}