#include <bits/stdc++.h>
using namespace std;
namespace debug {
template <class T>
string _str(const T x) {
  ostringstream str;
  str << x;
  return str.str();
}
string _str(const bool x) {
  ostringstream str;
  str << (x ? "true" : "false");
  return str.str();
}
string _str(const int x) {
  ostringstream str;
  str << x;
  return str.str();
}
string _str(const long long x) {
  ostringstream str;
  str << x;
  return str.str();
}
string _str(const char x) {
  ostringstream str;
  str << "'" << x << "'";
  return str.str();
}
string _str(const string x) {
  ostringstream str;
  str << '"' << x << '"';
  return str.str();
}
string _str(const double x) {
  ostringstream str;
  str.precision(6);
  str.setf(ios::fixed);
  str << x;
  return str.str();
}
string _str(const char* x) { return _str((string)x); }
template <class K, class V>
string _str(const pair<K, V> x);
template <class T>
string _str(const vector<T> x);
template <class T>
string _str(const set<T> x);
template <class K, class V>
string _str(const map<K, V> x);
template <class K, class V>
string _str(const pair<K, V> x) {
  ostringstream str;
  str << '(' << _str(x.first) << ", " << _str(x.second) << ')';
  return str.str();
}
template <class T>
string _str(const vector<T> x) {
  ostringstream str;
  str << "[";
  for (int i = 0; i < x.size(); ++i) {
    if (i) str << ", ";
    str << _str(x[i]);
  }
  str << "] size " << x.size();
  return str.str();
}
template <class T>
string _str(const set<T> x) {
  ostringstream str;
  str << "{";
  bool first = true;
  for (auto it : x) {
    if (!first) str << ", ";
    first = false;
    str << _str(it);
  }
  str << "} size " << x.size();
  return str.str();
}
template <class K, class V>
string _str(const map<K, V> x) {
  ostringstream str;
  str << "{";
  bool first = true;
  for (auto it : x) {
    if (!first) str << ", ";
    first = false;
    str << _str(it.first) << " -> " << _str(it.second);
  }
  str << "} size " << x.size();
  return str.str();
}
void _dvar(bool isfirst, vector<string>::iterator it) {}
template <typename TCur, typename... TArgs>
void _dvar(bool isfirst, vector<string>::iterator it, TCur cur, TArgs... x) {
  if (!isfirst) cerr << " | ";
  cerr << *it << " = " << _str(cur);
  _dvar(false, ++it, x...);
}
template <typename... TArgs>
void _d(string arg_names, TArgs... args) {
  int open = 0;
  vector<string> names;
  string cur;
  char wait_for_quote = 0;
  for (char c : arg_names) {
    if (c == ',' && open == 0 && !wait_for_quote) {
      names.push_back(cur);
      cur = "";
    } else {
      cur += c;
      if (wait_for_quote) {
        if (wait_for_quote == c) wait_for_quote = 0;
      } else {
        if (c == '\'' || c == '"')
          wait_for_quote = c;
        else {
          if (c == '(')
            open++;
          else if (c == ')')
            open--;
        }
      }
    }
  }
  if (((int)(cur).size())) {
    names.push_back(cur);
  }
  _dvar(true, names.begin(), args...);
  cout << endl;
}
}  // namespace debug
using namespace debug;
vector<vector<int>> adj;
vector<int> t;
vector<int> low;
int globalt;
vector<int> st;
vector<int> change;
vector<int> add;
vector<bool> vis;
void go(int x, int par = -1) {
  t[x] = low[x] = ++globalt;
  st.push_back(x);
  int saw = 0;
  for (int y : adj[x]) {
    if (!t[y]) go(y, x);
    if (y == par) saw++;
    if (y != par || saw > 1) {
      if (x == 2)
        ;
      ;
      low[x] = min(low[x], low[y]);
    }
  }
  if (low[x] >= t[x]) {
    vector<int> comp;
    while (st.back() != x) {
      comp.push_back(st.back());
      st.pop_back();
    }
    st.pop_back();
    comp.push_back(x);
    for (int i = (0); i < (((int)(comp).size())); ++i) {
      change[comp[i]] = comp[0];
    };
    ;
  }
}
namespace LCAOffline {
const int V = 200000;
template <int N>
struct Disjoint {
  int rank[N], p[N], n;
  int findset(int q) {
    int r = q, t;
    while (p[r] != r) r = p[r];
    while (p[q] != q) {
      t = p[q];
      p[q] = r;
      q = t;
    }
    return r;
  }
  void join(int q, int w) {
    q = findset(q);
    w = findset(w);
    if (rank[q] < rank[w])
      p[q] = w;
    else {
      p[w] = q;
      if (rank[q] == rank[w]) rank[w]++;
    }
  }
  void init(int _n) {
    n = _n;
    for (int i = (0); i < (n); ++i) {
      p[i] = i;
      rank[i] = 0;
    }
  }
};
vector<vector<int>> adj;
vector<vector<pair<int, int>>> queries;
vector<int> anc, res;
vector<int> comp;
int comps;
int n;
Disjoint<V> ds;
void dfs(int q, int from) {
  anc[q] = q;
  for (int i = (0); i < (((int)(adj[q]).size())); ++i) {
    int w = adj[q][i];
    if (w == from) continue;
    dfs(w, q);
    ds.join(q, w);
    anc[ds.findset(q)] = q;
  }
  comp[q] = comps;
  for (int i = (0); i < (((int)(queries[q]).size())); ++i)
    if (comp[queries[q][i].first] == comps) {
      res[queries[q][i].second] = anc[ds.findset(queries[q][i].first)];
    }
}
vector<int> build(const vector<vector<int>>& iadj,
                  const vector<pair<int, int>>& iqueries) {
  adj = iadj;
  n = ((int)(adj).size());
  comp = vector<int>(n);
  queries = vector<vector<pair<int, int>>>(n);
  for (int i = (0); i < (((int)(iqueries).size())); ++i) {
    queries[iqueries[i].first].push_back(pair<int, int>(iqueries[i].second, i));
    queries[iqueries[i].second].push_back(pair<int, int>(iqueries[i].first, i));
  }
  res = vector<int>(((int)(iqueries).size()), -1);
  anc = vector<int>(n);
  ds.init(n);
  comps = 0;
  for (int i = (0); i < (n); ++i)
    if (!comp[i]) {
      comps++;
      dfs(i, -1);
    }
  return res;
}
};  // namespace LCAOffline
bool dfs(int x, int par, vector<int>& up, vector<int>& down,
         vector<bool>& vis) {
  vis[x] = true;
  for (int y : adj[x])
    if (y != par) {
      if (!dfs(y, x, up, down, vis)) {
        return false;
      }
      up[x] += up[y];
      down[x] += down[y];
    }
  if (up[x] && down[x]) {
    return false;
  }
  return true;
}
int main() {
  std::ios_base::sync_with_stdio(false);
  int n, m, queries;
  cin >> n >> m >> queries;
  adj.resize(n);
  t.resize(n);
  low.resize(n);
  for (int i = (0); i < (m); ++i) {
    int q, w;
    cin >> q >> w;
    q--, w--;
    adj[q].push_back(w);
    adj[w].push_back(q);
  }
  change.resize(n);
  for (int i = (0); i < (n); ++i)
    if (!t[i]) {
      go(i);
    };
  ;
  ;
  ;
  vector<vector<int>> tadj(n);
  for (int i = (0); i < (n); ++i) {
    for (int j : adj[i])
      if (change[i] != change[j]) tadj[change[i]].push_back(change[j]);
  }
  adj.swap(tadj);
  for (int i = (0); i < (n); ++i) {
    sort((adj[i]).begin(), (adj[i]).end());
    adj[i].resize(unique((adj[i]).begin(), (adj[i]).end()) - adj[i].begin());
  }
  for (int i = (0); i < (n); ++i) {
    ;
    ;
  };
  ;
  vector<pair<int, int>> qp;
  vector<int> up(n), down(n);
  for (int i = (0); i < (queries); ++i) {
    int q, w;
    cin >> q >> w;
    --q, --w;
    q = change[q];
    w = change[w];
    qp.push_back(pair<int, int>(q, w));
    up[q]++;
    down[w]++;
  }
  vector<int> lca = LCAOffline::build(adj, qp);
  for (int i = (0); i < (((int)(lca).size())); ++i) {
    if (lca[i] == -1) {
      cout << "No" << endl;
      return 0;
    }
    up[lca[i]]--;
    down[lca[i]]--;
  };
  ;
  ;
  ;
  vector<bool> vis(n);
  for (int i = (0); i < (n); ++i) {
    if (!vis[i]) {
      if (!dfs(i, -1, up, down, vis)) {
        cout << "No" << endl;
        return 0;
      }
    }
  }
  cout << "Yes" << endl;
  return 0;
}
