import sys readline=sys.stdin.readline from typing import NamedTuple, Optional, List, cast class MFGraph: class Edge(NamedTuple): src: int dst: int cap: int flow: int class _Edge: def __init__(self, dst: int, cap: int) -> None: self.dst = dst self.cap = cap self.rev: Optional[MFGraph._Edge] = None def __init__(self, n: int) -> None: self._n = n self._g: List[List[MFGraph._Edge]] = [[] for _ in range(n)] self._edges: List[MFGraph._Edge] = [] def add_edge(self, src: int, dst: int, cap: int) -> int: assert 0 <= src < self._n assert 0 <= dst < self._n assert 0 <= cap m = len(self._edges) e = MFGraph._Edge(dst, cap) re = MFGraph._Edge(src, 0) e.rev = re re.rev = e self._g[src].append(e) self._g[dst].append(re) self._edges.append(e) return m def get_edge(self, i: int) -> Edge: assert 0 <= i < len(self._edges) e = self._edges[i] re = cast(MFGraph._Edge, e.rev) return MFGraph.Edge( re.dst, e.dst, e.cap + re.cap, re.cap ) def edges(self) -> List[Edge]: return [self.get_edge(i) for i in range(len(self._edges))] def change_edge(self, i: int, new_cap: int, new_flow: int) -> None: assert 0 <= i < len(self._edges) assert 0 <= new_flow <= new_cap e = self._edges[i] e.cap = new_cap - new_flow assert e.rev is not None e.rev.cap = new_flow def flow(self, s: int, t: int, flow_limit: Optional[int] = None) -> int: assert 0 <= s < self._n assert 0 <= t < self._n assert s != t if flow_limit is None: flow_limit = cast(int, sum(e.cap for e in self._g[s])) current_edge = [0] * self._n level = [0] * self._n def fill(arr: List[int], value: int) -> None: for i in range(len(arr)): arr[i] = value def bfs() -> bool: fill(level, self._n) queue = [] q_front = 0 queue.append(s) level[s] = 0 while q_front < len(queue): v = queue[q_front] q_front += 1 next_level = level[v] + 1 for e in self._g[v]: if e.cap == 0 or level[e.dst] <= next_level: continue level[e.dst] = next_level if e.dst == t: return True queue.append(e.dst) return False def dfs(lim: int) -> int: stack = [] edge_stack: List[MFGraph._Edge] = [] stack.append(t) while stack: v = stack[-1] if v == s: flow = min(lim, min(e.cap for e in edge_stack)) for e in edge_stack: e.cap -= flow assert e.rev is not None e.rev.cap += flow return flow next_level = level[v] - 1 while current_edge[v] < len(self._g[v]): e = self._g[v][current_edge[v]] re = cast(MFGraph._Edge, e.rev) if level[e.dst] != next_level or re.cap == 0: current_edge[v] += 1 continue stack.append(e.dst) edge_stack.append(re) break else: stack.pop() if edge_stack: edge_stack.pop() level[v] = self._n return 0 flow = 0 while flow < flow_limit: if not bfs(): break fill(current_edge, 0) while flow < flow_limit: f = dfs(flow_limit - flow) flow += f if f == 0: break return flow def min_cut(self, s: int) -> List[bool]: visited = [False] * self._n stack = [s] visited[s] = True while stack: v = stack.pop() for e in self._g[v]: if e.cap > 0 and not visited[e.dst]: visited[e.dst] = True stack.append(e.dst) return visited def SCC(N,edges): start = [0] * (N + 1) elist = [0] * len(edges) for e in edges: start[e[0] + 1] += 1 for i in range(1, N + 1): start[i] += start[i - 1] counter = start[:] for e in edges: elist[counter[e[0]]] = e[1] counter[e[0]] += 1 N = N now_ord = group_num = 0 visited = [] low = [0] * N order = [-1] * N ids = [0] * N parent = [-1] * N stack = [] for i in range(N): if order[i] == -1: stack.append(i) stack.append(i) while stack: v = stack.pop() if order[v] == -1: low[v] = order[v] = now_ord now_ord += 1 visited.append(v) for i in range(start[v], start[v + 1]): to = elist[i] if order[to] == -1: stack.append(to) stack.append(to) parent[to] = v else: low[v] = min(low[v], order[to]) else: if low[v] == order[v]: while True: u = visited.pop() order[u] = N ids[u] = group_num if u == v: break group_num += 1 if parent[v] != -1: low[parent[v]] = min(low[parent[v]], low[v]) for i, x in enumerate(ids): ids[i] = group_num - 1 - x groups = [[] for _ in range(group_num)] for i, x in enumerate(ids): groups[x].append(i) return groups def DM_Decomposition(N,M,edges): s=0 t=N+M+1 MFG=MFGraph(N+M+2) for n,m in edges: MFG.add_edge(1+n,1+m,1) for n in range(N): MFG.add_edge(s,1+n,1) for m in range(M): MFG.add_edge(1+N+m,t,1) MFG.flow(s,t) graph=[[] for x in range(N+M)] graph_rev=[[] for x in range(N+M)] covering=[False]*(N+M) for e in MFG.edges(): if 1<=e.src<1+N and 1+N<=e.dst<1+N+M: x=e.src-1 y=e.dst-1 if e.flow: graph[x].append(y) graph[y].append(x) graph_rev[x].append(y) graph_rev[y].append(x) covering[x]=True covering[y]=True else: graph[x].append(y) graph_rev[y].append(x) retu=[[]] seen=[False]*(N+M) stack=[] for m in range(M): if not covering[m+N]: stack.append(m+N) seen[m+N]=True while stack: x=stack.pop() retu[0].append(x) for y in graph_rev[x]: if not seen[y]: stack.append(y) seen[y]=True stack=[] V_inf=[] for n in range(N): if not covering[n]: seen[n]=True stack.append(n) while stack: x=stack.pop() V_inf.append(x) for y in graph[x]: if not seen[y]: stack.append(y) seen[y]=True scc_edges=[] for e in MFG.edges(): if 1<=e.src<1+N and 1+N<=e.dst<1+N+M: x=e.src-1 y=e.dst-1 if not seen[x] and not seen[y]: if e.flow: scc_edges.append((x,y)) scc_edges.append((y,x)) else: scc_edges.append((x,y)) scc=SCC(N+M,scc_edges) for lst in scc: if seen[lst[0]]: continue retu.append(lst) retu.append(V_inf) return retu N,M,L=map(int,readline().split()) edges=[] for l in range(L): x,y=map(int,readline().split()) x-=1;y-=1 edges.append((x,y+N)) dm=DM_Decomposition(N,M,edges) idx=[None]*(N+M) for i,lst in enumerate(dm): for x in lst: idx[x]=i for x,y in edges: if idx[x]==idx[y] and len(dm[idx[x]])==2: ans="No" else: ans="Yes" print(ans)