import sys
sys.setrecursionlimit(1 << 25)

def main():
    input = sys.stdin.read
    data = input().split()
    ptr = 0
    N = int(data[ptr])
    ptr += 1
    M = int(data[ptr])
    ptr += 1
    Q = int(data[ptr])
    ptr += 1

    edges = []
    adj = [[] for _ in range(N+1)]  # 1-based
    for i in range(M):
        u = int(data[ptr])
        ptr += 1
        v = int(data[ptr])
        ptr += 1
        edges.append((u, v))
        adj[u].append((v, i))
        adj[v].append((u, i))

    # Tarjan's algorithm to find bridges
    bridge = [False] * M
    disc = [-1] * (N + 1)
    low = [-1] * (N + 1)
    time_counter = [0]
    parent = [0] * (N + 1)
    stack = []

    for u in range(1, N + 1):
        if disc[u] == -1:
            stack.append((u, -1, False))
            while stack:
                node, parent_node, is_processed = stack.pop()
                if is_processed:
                    for v, idx in adj[node]:
                        if v != parent_node and disc[v] < disc[node]:
                            low[node] = min(low[node], disc[v])
                    if parent_node != -1:
                        low[parent_node] = min(low[parent_node], low[node])
                        if low[node] > disc[parent_node]:
                            bridge[idx] = True
                else:
                    if disc[node] != -1:
                        continue
                    disc[node] = low[node] = time_counter[0]
                    time_counter[0] += 1
                    stack.append((node, parent_node, True))
                    for v, idx in adj[node]:
                        if v == parent_node:
                            continue
                        if disc[v] == -1:
                            parent[v] = node
                            stack.append((v, node, False))
                        else:
                            low[node] = min(low[node], disc[v])

    # Build original_dsu
    class DSU:
        def __init__(self, size):
            self.parent = list(range(size + 1))  # 1-based
            self.rank = [1] * (size + 1)
        
        def find(self, x):
            if self.parent[x] != x:
                self.parent[x] = self.find(self.parent[x])
            return self.parent[x]
        
        def union(self, x, y):
            x_root = self.find(x)
            y_root = self.find(y)
            if x_root == y_root:
                return
            if self.rank[x_root] < self.rank[y_root]:
                self.parent[x_root] = y_root
            else:
                self.parent[y_root] = x_root
                if self.rank[x_root] == self.rank[y_root]:
                    self.rank[x_root] += 1

    original_dsu = DSU(N)
    for u, v in edges:
        original_dsu.union(u, v)

    # Build bridge_dsu
    bridge_dsu = DSU(N)
    for i in range(M):
        if bridge[i]:
            u, v = edges[i]
            bridge_dsu.union(u, v)

    # Process queries
    output = []
    for _ in range(Q):
        x = int(data[ptr])
        ptr += 1
        y = int(data[ptr])
        ptr += 1
        if original_dsu.find(x) != original_dsu.find(y):
            output.append("No")
        else:
            if bridge_dsu.find(x) == bridge_dsu.find(y):
                output.append("Yes")
            else:
                output.append("No")
    
    print('\n'.join(output))

if __name__ == "__main__":
    main()