#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
const long double Pi = 3.14159265359;
const long long MOD = 1000 * 1000 * 1000 + 7;
const long long N = 2e5 + 10;
const long long INF = 1e18;
const long long LOG = 20;
int par[LOG][N], n, m, v, u, fin[N], fup[N], Time, node[N], q;
vector<pair<int, int>> P;
vector<long long> g[N];
vector<long long> g1[N];
map<pair<long long, long long>, long long> chn;
map<pair<long long, long long>, int> ma;
int par1[N];
int sz[N];
int getpar(int v) {
  if (par1[v] == v) return v;
  return par1[v] = getpar(par1[v]);
}
void merge(int v, int u) {
  v = getpar(v);
  u = getpar(u);
  if (u == v) return;
  if (sz[v] < sz[u]) swap(v, u);
  par1[u] = v;
  sz[v] += sz[u];
}
int COM[N];
bitset<N> mark;
void DFS(long long v, int p = 0) {
  mark[v] = 1;
  fin[v] = fup[v] = ++Time;
  for (auto u : g[v]) {
    if (u == p) continue;
    if (!mark[u]) {
      DFS(u, v);
      fup[v] = min(fup[v], fup[u]);
      if (fin[v] < fup[u] && chn[{min(v, u), max(v, u)}] < 2) {
        ma[{min(v, u), max(v, u)}] = 1;
      }
    } else {
      fup[v] = min(fup[v], fin[u]);
    }
  }
}
void DFS1(long long v, long long col) {
  mark[v] = 1;
  COM[v] = col;
  for (auto u : g1[v]) {
    if (!mark[u]) DFS1(u, col);
  }
}
int h[N];
void DFSa(int v, int p = 0, int H = 0) {
  h[v] = H;
  par[0][v] = p;
  mark[v];
  for (int i = 1; i < LOG; i++) {
    par[i][v] = par[i - 1][par[i - 1][v]];
  }
  for (auto u : g[v]) {
    if (u == p) continue;
    DFSa(u, v, H + 1);
  }
}
int get_par(int v, int gam) {
  for (int i = 0; i < LOG; i++) {
    if (gam & (1 << i)) {
      v = par[i][v];
    }
  }
  return v;
}
map<pair<long long, long long>, long long> ma2;
int LCA(int v, int u) {
  if (h[v] < h[u]) swap(v, u);
  v = get_par(v, h[v] - h[u]);
  if (v == u) return v;
  for (int i = LOG - 1; i >= 0; i--) {
    if (par[i][v] != par[i][u]) {
      v = par[i][v], u = par[i][u];
    }
  }
  return par[0][v];
}
int DFS3(long long v, long long p = 0) {
  mark[v] = 1;
  long long ans = node[v];
  for (auto u : g[v]) {
    if (u == p) continue;
    ans += DFS3(u, v);
  }
  if (ans < 0)
    ma2[{v, p}] = 0;
  else
    ma2[{v, p}] = 1;
  return ans;
}
long long dp[N][2];
void DFS4(long long v, long long p = 0, long long H = 0) {
  mark[v] = 1;
  if (p == 0) {
    dp[v][0] = dp[v][1] = 0;
  } else {
    if (ma2[{v, p}] == 1) {
      dp[v][0] = H;
      dp[v][1] = dp[p][1];
    } else {
      dp[v][1] = H;
      dp[v][0] = dp[p][0];
    }
  }
  for (auto u : g[v]) {
    if (u == p) continue;
    DFS4(u, v, H + 1);
  }
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  vector<pair<long long, long long>> E;
  cin >> n >> m >> q;
  for (int i = 0; i < m; i++) {
    cin >> v >> u;
    g[v].push_back(u);
    g[u].push_back(v);
    chn[{min(u, v), max(u, v)}]++;
    E.push_back({u, v});
  }
  for (int i = 1; i <= n; i++) {
    if (!mark[i]) DFS(i);
  }
  for (int i = 0; i < m; i++) {
    if (ma.count({min(E[i].first, E[i].second),
                  max(E[i].first, E[i].second)}) != 1) {
      g1[E[i].first].push_back(E[i].second);
      g1[E[i].second].push_back(E[i].first);
    }
  }
  for (int i = 1; i <= n; i++) {
    g[i].clear();
  }
  long long Com = 1;
  for (int i = 0; i < N; i++) mark[i] = 0;
  for (int i = 1; i <= n; i++) {
    if (!mark[i]) {
      DFS1(i, Com);
      Com++;
    }
  }
  for (int i = 0; i < N; i++) par1[i] = i, sz[i] = 1;
  for (auto u : ma) {
    g[COM[u.first.first]].push_back(COM[u.first.second]);
    g[COM[u.first.second]].push_back(COM[u.first.first]);
    merge(COM[u.first.second], COM[u.first.first]);
  }
  vector<pair<long long, long long>> Q;
  for (int i = 0; i < q; i++) {
    cin >> v >> u;
    Q.push_back({v, u});
    if (getpar(COM[v]) != getpar(COM[u])) return cout << "No", 0;
    ;
    node[COM[v]]++;
    node[COM[u]]--;
  }
  for (int i = 0; i < N; i++) mark[i] = 0;
  for (int i = 1; i < Com; i++) {
    if (!mark[i]) {
      DFS3(i);
      DFS4(i);
      DFSa(i);
    }
  }
  for (int i = 0; i < Q.size(); i++) {
    long long vv = LCA(COM[Q[i].first], COM[Q[i].second]);
    if (dp[COM[Q[i].first]][1] > h[vv] || dp[COM[Q[i].second]][0] > h[vv])
      return cout << "No", 0;
    ;
  }
  return cout << "Yes", 0;
  ;
  return 0;
}
