def scc(N,edges):
    M=len(edges)
    start=[0]*(N+1)
    elist=[0]*M
    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
    visited=[]
    low=[0]*N
    Ord=[-1]*N
    ids=[0]*N
    NG=[0,0]
    def dfs(v):
        stack=[(v,-1,0),(v,-1,1)]
        while stack:
            v,bef,t=stack.pop()
            if t:
                if bef!=-1 and Ord[v]!=-1:
                    low[bef]=min(low[bef],Ord[v])
                    stack.pop()
                    continue
                low[v]=NG[0]
                Ord[v]=NG[0]
                NG[0]+=1
                visited.append(v)
                for i in range(start[v],start[v+1]):
                    to=elist[i]
                    if Ord[to]==-1:
                        stack.append((to,v,0))
                        stack.append((to,v,1))
                    else:
                        low[v]=min(low[v],Ord[to])
            else:
                if low[v]==Ord[v]:
                    while(True):
                        u=visited.pop()
                        Ord[u]=N
                        ids[u]=NG[1]
                        if u==v:
                            break
                    NG[1]+=1
                low[bef]=min(low[bef],low[v])
    for i in range(N):
        if Ord[i]==-1:
            dfs(i)
    for i in range(N):
        ids[i]=NG[1]-1-ids[i]
    group_num=NG[1]
    counts=[0]*group_num
    for x in ids:
        counts[x]+=1
    groups=[[] for i in range(group_num)]
    for i in range(N):
        groups[ids[i]].append(i)
    return groups

def eratosthenes(n):
    sieve = [True] * (n + 1)
    for i in range(int(n**0.5) + 1):
        if i < 2:
            sieve[i] = False
        elif sieve[i]:
            for j in range(2, n//i + 1):
                sieve[i * j] = False
    return sieve

N = int(input())
AB = [list(input().split()) for _ in range(N)]

E = eratosthenes(10**6)
edge = []
for i in range(N):
    A, B = AB[i]
    f = int(A+B)
    if E[f]:
        edge.append((i, N+i))
    t = int(B+A)
    if E[t]:
        edge.append((N+i, i))
for i in range(N-1):
    A1, B1 = AB[i]
    for j in range(i+1, N):
        A2, B2 = AB[j]
        a = int(A1+B2)
        b = int(A2+B1)
        if E[a] or E[b]:
            edge.append((i, N+j))
            edge.append((j, N+i))
        a = int(A1+A2)
        b = int(B2+B1)
        if E[a] or E[b]:
            edge.append((i, j))
            edge.append((N+j, N+i))
        a = int(B1+B2)
        b = int(A2+A1)
        if E[a] or E[b]:
            edge.append((N+i, N+j))
            edge.append((j, i))
        a = int(B1+A2)
        b = int(B2+A1)
        if E[a] or E[b]:
            edge.append((N+i, j))
            edge.append((N+j, i))

SCC = scc(N*2, edge)
IDX = [-1]*N
for i, S in enumerate(SCC):
    for s in S:
        if IDX[s%N] == -1:
            IDX[s%N] = i
        elif IDX[s%N] == i:
            exit(print("No"))

print("Yes")