#include <bits/stdc++.h>
using namespace std;
long long rdtsc() {
  long long tmp;
  asm("rdtsc" : "=A"(tmp));
  return tmp;
}
inline int myrand() { return abs((rand() << 15) ^ rand()); }
inline int rnd(int x) { return myrand() % x; }
const int INF = (int)1e9 + 1;
const long double EPS = 1e-9;
void precalc() {}
int n, m, q;
vector<vector<int> > es, num;
const int maxn = (int)2e5 + 10;
int pairs[maxn][2];
bool read() {
  if (scanf("%d%d%d", &n, &m, &q) < 3) {
    return 0;
  }
  es = num = vector<vector<int> >(n);
  for (int i = 0; i < m; ++i) {
    int s, t;
    scanf("%d%d", &s, &t);
    --s, --t;
    es[s].push_back(t), es[t].push_back(s);
    num[s].push_back(i), num[t].push_back(i);
  }
  for (int i = 0; i < q; ++i) {
    scanf("%d%d", &pairs[i][0], &pairs[i][1]);
    --pairs[i][0], --pairs[i][1];
  }
  return 1;
}
int used[maxn];
int mprev[maxn], w[maxn];
int get(int v) {
  if (mprev[v] == v) {
    return v;
  }
  return mprev[v] = get(mprev[v]);
}
void myUnion(int s, int t) {
  s = get(s), t = get(t);
  if (s == t) {
    return;
  }
  if (w[s] == w[t]) {
    ++w[s];
  }
  if (w[s] < w[t]) {
    swap(s, t);
  }
  mprev[t] = s;
}
int st[maxn];
int cnt;
void dfsch(int v, int eid = -1) {
  used[v] = 1;
  st[cnt++] = v;
  for (int it = 0; it < ((int)(es[v]).size()); ++it) {
    int u = es[v][it];
    if (used[u]) {
      if (eid != num[v][it]) {
        for (int p = cnt - 1; p >= 0; --p) {
          int curv = st[p];
          myUnion(curv, v);
          if (get(curv) == get(u)) {
            break;
          }
        }
      }
      continue;
    }
    dfsch(u, num[v][it]);
  }
  --cnt;
}
int ids[maxn];
int col[maxn];
void changeGraph() {
  for (int i = 0; i < n; ++i) {
    used[i] = 0;
  }
  for (int i = 0; i < n; ++i) {
    mprev[i] = i, w[i] = 0;
  }
  cnt = 0;
  for (int i = 0; i < n; ++i) {
    if (used[i]) {
      continue;
    }
    dfsch(i);
  }
  for (int i = 0; i < n; ++i) {
    ids[i] = get(i);
  }
  sort(ids, ids + n);
  int ccol = unique(ids, ids + n) - ids;
  for (int i = 0; i < n; ++i) {
    col[i] = lower_bound(ids, ids + ccol, get(i)) - ids;
  }
  vector<vector<int> > esrev(ccol);
  for (int i = 0; i < n; ++i) {
    for (int it = 0; it < ((int)(es[i]).size()); ++it) {
      int u = es[i][it];
      if (col[i] == col[u]) {
        continue;
      }
      esrev[col[i]].push_back(col[u]);
      esrev[col[u]].push_back(col[i]);
    }
  }
  for (int i = 0; i < q; ++i) {
    for (int j = 0; j < 2; ++j) {
      pairs[i][j] = col[pairs[i][j]];
    }
  }
  n = ccol;
  swap(es, esrev);
}
const int maxl = 18;
int pr[maxl][maxn];
int depth[maxn];
void dfs(int v) {
  used[v] = 1;
  for (int it = 0; it < ((int)(es[v]).size()); ++it) {
    int u = es[v][it];
    if (used[u]) {
      continue;
    }
    depth[u] = depth[v] + 1;
    pr[0][u] = v;
    dfs(u);
  }
}
int lca(int s, int t) {
  if (depth[s] < depth[t]) {
    swap(s, t);
  }
  for (int it = maxl - 1; it >= 0 && depth[s] > depth[t]; --it) {
    if (depth[s] - (1 << it) >= depth[t]) {
      s = pr[it][s];
    }
  }
  if (s == t) {
    return s;
  }
  for (int it = maxl - 1; it >= 0; --it) {
    if (pr[it][s] != pr[it][t]) {
      s = pr[it][s], t = pr[it][t];
    }
  }
  if (pr[0][s] == pr[0][t]) {
    return pr[0][s];
  }
  return -1;
}
int upc[maxn], till[maxn];
int dfsLast(int v) {
  used[v] = 1;
  for (int it = 0; it < ((int)(es[v]).size()); ++it) {
    int u = es[v][it];
    if (used[u]) {
      continue;
    }
    if (!dfsLast(u)) {
      return 0;
    }
  }
  if (upc[v] != -1 && depth[v] > 0) {
    int r = pr[0][v];
    assert(till[v] < depth[v]);
    if (till[v] < depth[r]) {
      if (upc[r] == !upc[v]) {
        return 0;
      }
      upc[r] = upc[v];
      till[r] = min(till[r], till[v]);
    }
  }
  return 1;
}
void solve() {
  changeGraph();
  for (int i = 0; i < n; ++i) {
    used[i] = 0;
  }
  for (int i = 0; i < n; ++i) {
    if (used[i]) {
      continue;
    }
    pr[0][i] = i;
    depth[i] = 0;
    dfs(i);
  }
  for (int it = 1; it < maxl; ++it) {
    for (int i = 0; i < n; ++i) {
      pr[it][i] = pr[it - 1][pr[it - 1][i]];
    }
  }
  for (int i = 0; i < n; ++i) {
    upc[i] = -1, till[i] = depth[i];
  }
  for (int i = 0; i < q; ++i) {
    int s = pairs[i][0], t = pairs[i][1];
    int r = lca(s, t);
    if (r == -1) {
      printf("No\n");
      return;
    }
    if (s != r) {
      if (upc[s] == 1) {
        printf("No\n");
        return;
      }
      upc[s] = 0;
      till[s] = min(till[s], depth[r]);
    }
    if (t != r) {
      if (upc[t] == 0) {
        printf("No\n");
        return;
      }
      upc[t] = 1;
      till[t] = min(till[t], depth[r]);
    }
  }
  for (int i = 0; i < n; ++i) {
    used[i] = 0;
  }
  for (int i = 0; i < n; ++i) {
    if (used[i]) {
      continue;
    }
    if (!dfsLast(i)) {
      printf("No\n");
      return;
    }
  }
  printf("Yes\n");
}
int main() {
  srand(rdtsc());
  precalc();
  while (1) {
    if (!read()) {
      break;
    }
    solve();
  }
  return 0;
}
