#include <bits/stdc++.h>
using namespace std;
const int maxn = 200005, maxm = 200005;
vector<int> tree[maxn];
vector<int> graph[maxn];
int U[maxm], V[maxm];
bool isbridge[maxm];
int visited[maxn];
int times[maxn], T;
int cmpno;
queue<int> q[maxn];
int comp[maxn], comp2[maxn];
int adj(int u, int e) { return U[e] == u ? V[e] : U[e]; }
int tarjan(int u, int edge) {
  comp2[u] = cmpno;
  visited[u] = 1;
  times[u] = T++;
  int disc = times[u];
  for (int i = 0; i < graph[u].size(); i++) {
    int e = graph[u][i];
    int w = adj(u, e);
    if (!visited[w])
      disc = min(disc, tarjan(w, e));
    else if (e != edge)
      disc = min(disc, times[w]);
  }
  if (disc == times[u] && edge != -1) isbridge[edge] = true;
  return disc;
}
void bridged_tree(int v) {
  int currcmp = cmpno;
  q[currcmp].push(v);
  visited[v] = 1;
  while (!q[currcmp].empty()) {
    int u = q[currcmp].front();
    q[currcmp].pop();
    comp[u] = currcmp;
    for (int i = 0; i < graph[u].size(); i++) {
      int e = graph[u][i];
      int w = adj(u, e);
      if (visited[w]) continue;
      if (isbridge[e]) {
        cmpno++;
        tree[currcmp].push_back(cmpno);
        tree[cmpno].push_back(currcmp);
        bridged_tree(w);
      } else {
        q[currcmp].push(w);
        visited[w] = 1;
      }
    }
  }
}
const int LOG = 20;
int level[maxn];
int ancestor[LOG][maxn];
int up[maxn], down[maxn];
void dfs_lca(int u, int p) {
  visited[u] = 1;
  for (const auto &v : tree[u]) {
    if (v == p || visited[v]) continue;
    ancestor[0][v] = u;
    level[v] = level[u] + 1;
    dfs_lca(v, u);
  }
}
void preprocess(int n) {
  for (int i = 1; i < LOG; i++) {
    for (int j = 1; j <= n; j++)
      ancestor[i][j] = ancestor[i - 1][ancestor[i - 1][j]];
  }
}
int lca(int u, int v) {
  if (level[u] > level[v]) swap(u, v);
  int d = level[v] - level[u];
  for (int i = 0; i < LOG; i++) {
    if (d & (1 << i)) {
      v = ancestor[i][v];
    }
  }
  if (v == u) return v;
  for (int i = LOG - 1; i >= 0; i--) {
    if (ancestor[i][u] != ancestor[i][v]) {
      u = ancestor[i][u];
      v = ancestor[i][v];
    }
  }
  return ancestor[0][u];
}
bool ok = 1;
void dfs3(int u, int p) {
  visited[u] = 1;
  for (const auto &v : tree[u]) {
    if (p == v || visited[v]) continue;
    up[u] += up[v];
    down[u] += down[v];
  }
  if (up[u] > 0 && down[u] > 0) ok = false;
}
int main() {
  int n, m, q;
  scanf("%d %d %d", &n, &m, &q);
  for (int i = 1; i <= m; i++) {
    scanf("%d %d", &U[i], &V[i]);
    graph[U[i]].push_back(i);
    graph[V[i]].push_back(i);
  }
  memset(visited, 0, sizeof(visited));
  for (int i = 1; i <= n; i++) {
    if (visited[i] == 0) {
      tarjan(i, -1);
      cmpno++;
    }
  }
  memset(visited, 0, sizeof(visited));
  cmpno = 0;
  for (int i = 1; i <= n; i++) {
    if (visited[i] == 0) {
      bridged_tree(i);
      cmpno++;
    }
  }
  memset(visited, 0, sizeof(visited));
  for (int i = 0; i < cmpno; i++) {
    if (visited[i] == 0) {
      level[i] = 0;
      dfs_lca(i, i);
    }
  }
  preprocess(cmpno);
  while (q--) {
    int u, v;
    scanf("%d %d", &u, &v);
    if (comp2[u] != comp2[v]) {
      ok = false;
      continue;
    }
    if (comp[u] == comp[v]) continue;
    u = comp[u];
    v = comp[v];
    int l = lca(u, v);
    if (ok) {
      up[u]++;
      down[v]++;
      up[l]--;
      down[l]--;
    }
  }
  memset(visited, 0, sizeof(visited));
  for (int i = 0; i < n; i++) {
    if (visited[i] == 0) {
      dfs3(i, -1);
    }
  }
  printf("%s\n", ok ? "Yes" : "No");
  return 0;
}
