Andrewid the Android is a galaxy-known detective. Now he is preparing a defense against a possible attack by hackers on a major computer network.

In this network are *n* vertices, some pairs of vertices are connected by *m* undirected channels. It is planned to transfer *q* important messages via this network, the *i*-th of which must be sent from vertex *s*<sub class="lower-index">*i*</sub> to vertex *d*<sub class="lower-index">*i*</sub> via one or more channels, perhaps through some intermediate vertices.

To protect against attacks a special algorithm was developed. Unfortunately it can be applied only to the network containing directed channels. Therefore, as new channels can't be created, it was decided for each of the existing undirected channels to enable them to transmit data only in one of the two directions.

Your task is to determine whether it is possible so to choose the direction for each channel so that each of the *q* messages could be successfully transmitted.
The first line contains three integers *n*, *m* and *q* (1 ≤ *n*, *m*, *q* ≤ 2·10<sup class="upper-index">5</sup>) — the number of nodes, channels and important messages.

Next *m* lines contain two integers each, *v*<sub class="lower-index">*i*</sub> and *u*<sub class="lower-index">*i*</sub> (1 ≤ *v*<sub class="lower-index">*i*</sub>, *u*<sub class="lower-index">*i*</sub> ≤ *n*, *v*<sub class="lower-index">*i*</sub> ≠ *u*<sub class="lower-index">*i*</sub>), that means that between nodes *v*<sub class="lower-index">*i*</sub> and *u*<sub class="lower-index">*i*</sub> is a channel. Between a pair of nodes can exist more than one channel.

Next *q* lines contain two integers *s*<sub class="lower-index">*i*</sub> and *d*<sub class="lower-index">*i*</sub> (1 ≤ *s*<sub class="lower-index">*i*</sub>, *d*<sub class="lower-index">*i*</sub> ≤ *n*, *s*<sub class="lower-index">*i*</sub> ≠ *d*<sub class="lower-index">*i*</sub>) — the numbers of the nodes of the source and destination of the corresponding message.

It is not guaranteed that in it initially possible to transmit all the messages.
if True:
    from io import BytesIO, IOBase
    import math

    import random
    import sys
    import os

    import bisect
    import typing
    from collections import Counter, defaultdict, deque
    from copy import deepcopy
    from functools import cmp_to_key, lru_cache, reduce
    from heapq import heapify, heappop, heappush, heappushpop, nlargest, nsmallest
    from itertools import accumulate, combinations, permutations, count
    from operator import add, iand, ior, itemgetter, mul, xor
    from string import ascii_lowercase, ascii_uppercase, ascii_letters
    from typing import *
    BUFSIZE = 4096

    class FastIO(IOBase):
        newlines = 0

        def __init__(self, file):
            self._fd = file.fileno()
            self.buffer = BytesIO()
            self.writable = "x" in file.mode or "r" not in file.mode
            self.write = self.buffer.write if self.writable else None

        def read(self):
            while True:
                b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
                if not b:
                    break
                ptr = self.buffer.tell()
                self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
            self.newlines = 0
            return self.buffer.read()

        def readline(self):
            while self.newlines == 0:
                b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
                self.newlines = b.count(b"\n") + (not b)
                ptr = self.buffer.tell()
                self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
            self.newlines -= 1
            return self.buffer.readline()

        def flush(self):
            if self.writable:
                os.write(self._fd, self.buffer.getvalue())
                self.buffer.truncate(0), self.buffer.seek(0)

    class IOWrapper(IOBase):
        def __init__(self, file):
            self.buffer = FastIO(file)
            self.flush = self.buffer.flush
            self.writable = self.buffer.writable
            self.write = lambda s: self.buffer.write(s.encode("ascii"))
            self.read = lambda: self.buffer.read().decode("ascii")
            self.readline = lambda: self.buffer.readline().decode("ascii")

    sys.stdin = IOWrapper(sys.stdin)
    sys.stdout = IOWrapper(sys.stdout)
    input = lambda: sys.stdin.readline().rstrip("\r\n")
    
    def I():
        return input()

    def II():
        return int(input())

    def MII():
        return map(int, input().split())

    def LI():
        return list(input().split())

    def LII():
        return list(map(int, input().split()))

    def GMI():
        return map(lambda x: int(x) - 1, input().split())

    def LGMI():
        return list(map(lambda x: int(x) - 1, input().split()))

    inf = float('inf')

dfs, hashing, timeit = True, False, True

if dfs:
    from types import GeneratorType

    def bootstrap(f, stack=[]):
        def wrappedfunc(*args, **kwargs):
            if stack:
                return f(*args, **kwargs)
            else:
                to = f(*args, **kwargs)
                while True:
                    if type(to) is GeneratorType:
                        stack.append(to)
                        to = next(to)
                    else:
                        stack.pop()
                        if not stack:
                            break
                        to = stack[-1].send(to)
                return to
        return wrappedfunc

if hashing:
    RANDOM = random.getrandbits(20)
    class Wrapper(int):
        def __init__(self, x):
            int.__init__(x)

        def __hash__(self):
            return super(Wrapper, self).__hash__() ^ RANDOM

if True:
    import time
    def timer(func):
        def wrapper(*args, **kwargs):
            start = time.time()
            result = func(*args, **kwargs)
            end = time.time()
            print(f'Time Used: {round((end - start) * 1000)} ms')
            return result
        return wrapper if timeit else func

class LCA:
    def __init__(self, g, root, f=max, ide_ele=0):
        # g[v]: (cost, u)
        self.n = len(g)
        self.root = root
        self.f = f
        self.ide_ele = ide_ele
        self.num = (self.n).bit_length()
        self.depth = [0]*self.n
        self.parent = [[-1]*self.n for i in range(self.num)]
        self.size = [1]*n
 
        s = [root]
        order = []
        while s:
            v = s.pop()
            order.append(v)
            for u in g[v]:
                if u == self.parent[0][v]:
                    continue
                self.parent[0][u] = v
                self.depth[u] = self.depth[v]+1
                s.append(u)
        order.reverse()
        for v in order:
            p = self.parent[0][v]
            if p != -1:
                self.size[p] += self.size[v]
        self.order = order
        # doubling
        for k in range(self.num-1):
            for v in range(self.n):
                if self.parent[k][v] == -1:
                    self.parent[k+1][v] = -1
                else:
                    self.parent[k+1][v] = self.parent[k][self.parent[k][v]]
 
    def getLCA(self, u, v):
        if self.depth[u] > self.depth[v]:
            u, v = v, u
        for k in range(self.num):
            if ((self.depth[v]-self.depth[u]) >> k) & 1:
                v = self.parent[k][v]
        if u == v:
            return u
 
        for k in reversed(range(self.num)):
            if self.parent[k][u] != self.parent[k][v]:
                u = self.parent[k][u]
                v = self.parent[k][v]
        return self.parent[0][u]
 
    def search(self, v, x):
        for k in reversed(range(self.num)):
            if (x>>k)&1:
                v = self.parent[k][v]
        return v

class UnionFind:
    def __init__(self, n):
        self.parent = list(range(n))

    def find(self, a):
        a = self.parent[a]
        acopy = a
        while a != self.parent[a]:
            a = self.parent[a]
        while acopy != a:
            self.parent[acopy], acopy = a, self.parent[acopy]
        return a

    def merge(self, a, b):
        pa, pb = self.find(a), self.find(b)
        if pa == pb: return False
        self.parent[pb] = pa
        return True

n, m, q = MII()
union = UnionFind(n)
edges = set()
for _ in range(m):
    u, v = GMI()
    if (u, v) in edges or (v, u) in edges:
        union.merge(u, v)
    else:
        edges.add((u, v))

path = [[] for _ in range(n)]

for u, v in edges:
    u = union.find(u)
    v = union.find(v)
    path[u].append(v)
    path[v].append(u)

dfn = [0] * n
low = [0] * n
col = [0] * n
color = tmstamp = 0
stack = []

@bootstrap
def tarjan(u, f):
    global color, tmstamp
    tmstamp += 1
    dfn[u] = low[u] = tmstamp
    stack.append(u)
    for v in path[u]:
        if dfn[v] == 0:
            yield tarjan(v, u)
            low[u] = min(low[u], low[v])
        elif v != f: low[u] = min(low[u], dfn[v])
    if low[u] == dfn[u]:
        while True:
            col[stack[-1]] = color
            tmp = stack.pop()
            if tmp == u: break
        color += 1
    yield

tarjan(0, -1)

col_path = [set() for _ in range(color)]
for u in range(n):
    for v in path[u]:
        if col[u] != col[v]:
            col_path[col[u]].add(col[v])
            col_path[col[v]].add(col[u])

lca = LCA(col_path, 0)
parent = lca.parent[0]
order = lca.order

up = [0] * color
down = [0] * color
for _ in range(q):
    u, v = GMI()
    u = union.find(u)
    v = union.find(v)
    u, v = col[u], col[v]
    l = lca.getLCA(u, v)
    up[u] += 1
    up[l] -= 1
    down[v] += 1
    down[l] -= 1

for i in order:
    if i:
        up[parent[i]] += up[i]
        down[parent[i]] += down[i]

for i in range(color):
    if up[i] and down[i]:
        print('No')
        break
else: print('Yes')