#include <bits/stdc++.h>
using namespace std;
const int Max_N(200050);
const int Max_M(200050);
namespace io {
const int SIZE = (1 << 21) + 1;
char ibuf[SIZE], *iS, *iT, obuf[SIZE], *oS = obuf, *oT = oS + SIZE - 1, c,
                                       qu[55];
int f, qr;
inline void flush() {
  fwrite(obuf, 1, oS - obuf, stdout);
  oS = obuf;
}
inline void putc(char x) {
  *oS++ = x;
  if (oS == oT) flush();
}
template <class I>
inline void gi(I &x) {
  for (f = 1, c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
                              (iS == iT ? EOF : *iS++))
                            : *iS++);
       c < '0' || c > '9';
       c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
                       (iS == iT ? EOF : *iS++))
                     : *iS++))
    if (c == '-') f = -1;
  for (x = 0; c <= '9' && c >= '0';
       c = (iS == iT ? (iT = (iS = ibuf) + fread(ibuf, 1, SIZE, stdin),
                       (iS == iT ? EOF : *iS++))
                     : *iS++))
    x = x * 10 + (c & 15);
  x *= f;
}
template <class I>
inline void print(I x) {
  if (!x) putc('0');
  if (x < 0) putc('-'), x = -x;
  while (x) qu[++qr] = x % 10 + '0', x /= 10;
  while (qr) putc(qu[qr--]);
}
struct Flusher_ {
  ~Flusher_() { flush(); }
} io_flusher_;
}  // namespace io
using io::gi;
using io::print;
using io::putc;
inline void GG() { putc('N'), putc('o'), exit(0); }
int N, M, Q, Head[Max_N], Total, To[Max_M << 1], Next[Max_M << 1], dfsclock,
    Pre[Max_N];
bool Cut[Max_M << 1];
inline void Add_Edge(int tot, int s, int t) {
  To[tot] = t, Next[tot] = Head[s], Head[s] = tot;
}
inline void Add_Link(int u, int v) {
  Total += 2, Add_Edge(Total, u, v), Add_Edge(Total ^ 1, v, u);
}
int Tarjan(int u, int fa) {
  int lowu(Pre[u] = ++dfsclock);
  for (int i = Head[u], v, lowv; i; i = Next[i])
    if (!Pre[v = To[i]]) {
      lowu = min(lowu, lowv = Tarjan(v, i));
      if (lowv > Pre[u]) Cut[i] = Cut[i ^ 1] = true;
    } else if (Pre[v] < Pre[u] && i != fa && (i ^ 1) != fa)
      lowu = min(lowu, Pre[v]);
  return lowu;
}
namespace T {
int N, Head[Max_N], Total, To[Max_N << 1], Next[Max_N << 1], root[Max_N],
    Father[Max_N], Deep[Max_N], Size[Max_N], Son[Max_N], Top[Max_N], A[Max_N],
    B[Max_N];
inline void Add_Edge(int s, int t) {
  ++Total, To[Total] = t, Next[Total] = Head[s], Head[s] = Total;
}
void dfs1(int u) {
  Size[u] = 1;
  for (int i = Head[u], v; i; i = Next[i])
    if ((v = To[i]) != Father[u]) {
      root[v] = root[u], Father[v] = u, Deep[v] = Deep[u] + 1, dfs1(v),
      Size[u] += Size[v];
      if (Size[v] > Size[Son[u]]) Son[u] = v;
    }
}
void dfs2(int u) {
  int v;
  if (v = Son[u]) Top[v] = Top[u], dfs2(v);
  for (int i = Head[u]; i; i = Next[i])
    if ((v = To[i]) != Father[u] && v != Son[u]) Top[v] = v, dfs2(v);
}
void prepare() {
  for (int u = 1; u <= N; ++u)
    if (!root[u]) root[u] = u, dfs1(u), Top[u] = u, dfs2(u);
}
int LCA(int u, int v) {
  int r1(Top[u]), r2(Top[v]);
  while (r1 != r2) {
    if (Deep[r1] < Deep[r2]) swap(r1, r2), swap(u, v);
    u = Father[r1], r1 = Top[u];
  }
  if (Deep[u] > Deep[v]) swap(u, v);
  return u;
}
void check(int u) {
  for (int i = Head[u], v; i; i = Next[i])
    if ((v = To[i]) != Father[u]) check(v), A[u] += A[v], B[u] += B[v];
  if (A[u] && B[u]) GG();
}
void check() {
  for (int u = 1; u <= N; ++u)
    if (root[u] == u) check(u);
}
}  // namespace T
int BCC[Max_N];
void dfs(int u) {
  BCC[u] = T::N;
  for (int i = Head[u], v; i; i = Next[i])
    if (!BCC[v = To[i]] && Cut[i] == false) dfs(v);
}
int main() {
  gi(N), gi(M), gi(Q);
  for (int i = 1, u, v; M--;) gi(u), gi(v), Add_Link(u, v);
  for (int u = 1; u <= N; ++u)
    if (!Pre[u]) Tarjan(u, -1);
  for (int u = 1; u <= N; ++u)
    if (!BCC[u]) ++T::N, dfs(u);
  for (int u = 1; u <= N; ++u)
    for (int i = Head[u], v; i; i = Next[i])
      if (BCC[u] != BCC[v = To[i]]) T::Add_Edge(BCC[u], BCC[v]);
  T::prepare();
  for (int s, t, lca; Q--;) {
    gi(s), gi(t);
    if ((s = BCC[s]) == (t = BCC[t])) continue;
    if (T::root[s] != T::root[t]) GG();
    lca = T::LCA(s, t);
    ++T::A[s], --T::A[lca];
    ++T::B[t], --T::B[lca];
  }
  T::check();
  putc('Y'), putc('e'), putc('s');
  return 0;
}
