#include <bits/stdc++.h>
using namespace std;
vector<vector<pair<int, int> > > iG;
vector<vector<int> > G;
vector<pair<int, int> > E, Q, B;
vector<int> dir;
vector<int> low, d;
int n, m, q;
int Time = 0;
const int Dir_Up = 1, Dir_Down = -1;
vector<int> dsu;
int setCount;
int find(int i) { return dsu[i] < 0 ? i : dsu[i] = find(dsu[i]); }
bool same(int i, int j) { return find(i) == find(j); }
void join(int i, int j) {
  if (same(i, j)) return;
  --setCount, i = find(i), j = find(j);
  if (dsu[i] > dsu[j]) swap(i, j);
  dsu[i] += dsu[j];
  dsu[j] = i;
}
void initDsu(int size) {
  setCount = size;
  dsu.assign(size, -1);
  ;
}
void Exit(string ans) {
  cout << ans << endl;
  exit(0);
}
void add_edge(int u, int v) { E.push_back(pair<int, int>(u, v)); }
void tarjan(int v, int par = -1) {
  d[v] = low[v] = ++Time;
  for (int i = 0; i < (int)iG[v].size(); ++i) {
    int u = iG[v][i].first;
    if (iG[v][i].second == par) continue;
    if (d[u]) {
      low[v] = min(low[v], d[u]);
      add_edge(u, v);
    } else {
      tarjan(u, iG[v][i].second);
      if (low[u] < d[u])
        add_edge(u, v);
      else
        B.push_back(pair<int, int>(u, v));
      low[v] = min(low[v], low[u]);
    }
  }
}
vector<vector<int> > par;
vector<int> L;
vector<int> Up, Down;
int find_v(vector<int>& S, int i) {
  return (S[i] == i ? i : S[i] = find_v(S, S[i]));
}
void join_v(vector<int>& S, int i, int j) { S[i] = j; }
void build_lca(int v) {
  for (int i = 0; i < (int)19; ++i) par[v][i + 1] = par[par[v][i]][i];
  Up[v] = Down[v] = v;
  for (int i = 0; i < (int)G[v].size(); ++i) {
    int u = G[v][i];
    if (u == par[v][0] || par[u][0]) continue;
    par[u][0] = v;
    L[u] = L[v] + 1;
    build_lca(u);
  }
}
int lca(int u, int v) {
  if (L[v] < L[u]) swap(u, v);
  for (int i = 19; i >= (int)0; --i)
    if (L[v] - (1 << i) >= L[u]) v = par[v][i];
  for (int i = 19; i >= (int)0; --i)
    if (par[u][i] != par[v][i]) u = par[u][i], v = par[v][i];
  return (u == v ? u : par[u][0]);
}
void process_query(int u, int v) {
  if (same(u, v)) return;
  u = find(u), v = find(v);
  int k = lca(u, v);
  u = find_v(Up, u), v = find_v(Down, v);
  while (L[u] > L[k])
    if (dir[u] == Dir_Down)
      Exit("No");
    else {
      dir[u] = Dir_Up;
      join_v(Up, u, par[u][0]);
      u = find_v(Up, u);
    }
  while (L[v] > L[k])
    if (dir[v] == Dir_Up)
      Exit("No");
    else {
      dir[v] = Dir_Down;
      join_v(Down, v, par[v][0]);
      v = find_v(Down, v);
    }
}
void process_data() {
  cin >> n >> m >> q;
  iG.assign(n + 1, vector<pair<int, int> >());
  ;
  d.assign(n + 1, 0);
  ;
  low.assign(n + 1, 0);
  ;
  initDsu(n + 1);
  int u, v;
  for (int i = 1; i < (int)m + 1; ++i) {
    cin >> u >> v;
    iG[u].push_back(pair<int, int>(v, i));
    iG[v].push_back(pair<int, int>(u, i));
    join(u, v);
  }
  while (q--) {
    cin >> u >> v;
    Q.push_back(pair<int, int>(u, v));
    if (!same(u, v)) Exit("No");
  }
  initDsu(n + 1);
  for (int i = 1; i < (int)n + 1; ++i)
    if (!d[i]) tarjan(i);
  for (int i = 0; i < (int)E.size(); ++i) join(E[i].first, E[i].second);
  G.assign(n + 1, vector<int>());
  ;
  par.assign(n + 1, vector<int>(20));
  ;
  L.assign(n + 1, 0);
  ;
  Up.assign(n + 1, 0);
  ;
  Down.assign(n + 1, 0);
  ;
  for (int i = 0; i < (int)B.size(); ++i) {
    G[find(B[i].first)].push_back(find(B[i].second));
    G[find(B[i].second)].push_back(find(B[i].first));
  }
  for (int i = 1; i < (int)n + 1; ++i)
    if (i == find(i) && !par[i][0]) {
      L[i] = 1;
      build_lca(i);
    }
  dir.assign(n + 1, 0);
  ;
  for (int i = 0; i < (int)Q.size(); ++i)
    process_query(Q[i].first, Q[i].second);
  Exit("Yes");
}
int main() {
  ios_base::sync_with_stdio(false);
  process_data();
}
