int boss[N];
void init() {
  for (int i=0; i<N; i++)
    boss[i] = i;
}
int find_boss(int x) {
  if (x == boss[x])
    return x;
  return find_boss(boss[x]);
}
int merge(int x, int y) {
  boss[find_boss(y)] = find_boss(x);
}

boss = list(range(n))
def find_boss(x):
  if x == boss[x]:
    return x
  return find_boss(boss[x])

def merge(x, y):
  boss[find_boss(y)] = find_boss(x)

int boss[N];
void init() {
  for (int i=0; i<N; i++)
    boss[i] = i;
}
int find_boss(int x) {
  if (x == boss[x])
    return x;
  return find_boss(boss[x]);
}
int merge(int x, int y) {
  boss[find_boss(y)] = find_boss(x);
}

boss = list(range(n))
def find_boss(x):
  if x == boss[x]:
    return x
  return find_boss(boss[x])

def merge(x, y):
  boss[find_boss(y)] = find_boss(x)

int boss[N];
void init() {
  for (int i=0; i<N; i++)
    boss[i] = i;
}
int find_boss(int x) {
  if (x == boss[x])
    return x;
  return find_boss(boss[x]);
}
int merge(int x, int y) {
  boss[find_boss(y)] = find_boss(x);
}

boss = list(range(n))
def find_boss(x):
  if x == boss[x]:
    return x
  return find_boss(boss[x])

def merge(x, y):
  boss[find_boss(y)] = find_boss(x)

int boss[N];
void init() {
  for (int i=0; i<N; i++)
    boss[i] = i;
}
int find_boss(int x) {
  if (x == boss[x])
    return x;
  return boss[x] = find_boss(boss[x]);
}
int merge(int x, int y) {
  boss[find_boss(y)] = find_boss(x);
}

boss = list(range(n))
def find_boss(x):
  if x == boss[x]:
    return x
  boss[x] = find_boss(boss[x])
  return boss[x]

def merge(x, y):
  boss[find_boss(y)] = find_boss(x)

int boss[N], rank[N]={};
void init() {
  for (int i=0; i<N; i++)
    boss[i] = i;
}
int find_boss(int x) {
  if (x == boss[x])
    return x;
  return find_boss(boss[x]);
}
void merge(int x, int y) {
  int boss_x = find_boss(x);
  int boss_y = find_boss(y);
  if (boss_x == boss_y)
    return ;
  if (rank[boss_x] > rank[boss_y]) {
    boss[boss_y] = boss_x;
  } else {
    boss[boss_x] = boss_y;
    if (rank[boss_x] == rank[boss_y])
      rank[boss_y] ++;
  }
}

boss = list(range(N))
rank = [0] * N
def find_boss(x):
  if x == boss[x]:
    return x
  return find_boss(boss[x])

def merge(x, y):
  boss_x = find_boss(x)
  boss_y = find_boss(y)
  if boss_x == boss_y:
    return
  if rank[boss_x] > rank[boss_y]:
    boss[boss_y] = boss_x
  else:
    boss[boss_x] = boss_y
    if rank[boss_x] == rank[boss_y]:
      rank[boss_y] += 1

int boss[N], rank[N]={};
void init() {
  for (int i=0; i<N; i++)
    boss[i] = i;
}
int find_boss(int x) {
  if (x == boss[x])
    return x;
  return boss[x] = find_boss(boss[x]);
}
void merge(int x, int y) {
  int boss_x = find_boss(x);
  int boss_y = find_boss(y);
  if (boss_x == boss_y)
    return ;
  if (rank[boss_x] > rank[boss_y]) {
    boss[boss_y] = boss_x;
  } else {
    boss[boss_x] = boss_y;
    if (rank[boss_x] == rank[boss_y])
      rank[boss_y] ++;
  }
}

boss = list(range(N))
rank = [0] * N
def find_boss(x):
  if x != boss[x]:
    boss[x] = find_boss(boss[x])
  return boss[x]

def merge(x, y):
  boss_x = find_boss(x)
  boss_y = find_boss(y)
  if boss_x == boss_y:
    return
  if rank[boss_x] > rank[boss_y]:
    boss[boss_y] = boss_x
  else:
    boss[boss_x] = boss_y
    if rank[boss_x] == rank[boss_y]:
      rank[boss_y] += 1

#include <stdio.h>
#define N 10001
int boss[N], rank[N] = {};
// DSU 模板 code
int main()
{
    int n, m, q, x, y;
    scanf("%d%d%d", &n, &m, &q);
    init();
    while (m--) {
        scanf("%d%d", &x, &y);
        merge(x, y);
    }
    while (q--) {
        scanf("%d%d", &x, &y);
        printf(":%c\n", "()"[find_boss(x) == find_boss(y)]);
    }
    return 0;
}

N, m, q = map(int, input().split())
boss = list(range(N+1))
rank = [0] * (N+1)
# DSU 模板 code
for _ in range(m):
    x, y = map(int, input().split())
    merge(x, y)

for _ in range(q):
    x, y = map(int, input().split())
    if find_boss(x) == find_boss(y):
       print(":)")
    else:
       print(":(")

class Solution {
public:
    unordered_map<string, string> boss;
    unordered_map<string, int> rank;
    unordered_map<string, int> account_to_idx;

    // DSU 模板
    string find_boss(string x) {
        if (boss[x] == x)
            return x;
        return boss[x] = find_boss(boss[x]);
    }

    void merge(string x, string y) {
        string bossX = find_boss(x);
        string bossY = find_boss(y);
        if (bossX != bossY) {
            if (rank[bossX] > rank[bossY]) {
                boss[bossY] = bossX;
            } else{
                boss[bossX] = bossY;
                if (rank[bossX] == rank[bossY]) 
	                rank[bossY]++;
            }
        }
    }
// .....
 

   vector<vector<string>> accountsMerge(vector<vector<string>>& accounts) {
        // 初始化，以及開始合併
        for (int i = 0; i < accounts.size(); i++) {
            auto &account_list = accounts[i];
            for (int j = 1; j < account_list.size(); j++) {
                string &account = account_list[j];
                if (boss.find(account) == boss.end()) {
                    boss[account] = account;
                    rank[account] = 0;
                }
                account_to_idx[account] = i;
                merge(account, account_list[1]);
            }
        }

        // 蒐集答案
        unordered_map<string, set<string>> pre_answer;
        for (int i = 0; i < accounts.size(); i++) {
            auto &account_list = accounts[i];
            for (int j = 1; j < account_list.size(); j++) {
                string &account = account_list[j];
                pre_answer[find_boss(account)].insert(account);
            }
        }

        // 輸出答案
        vector<vector<string>> answer;
        for (auto &[root, account_set] : pre_answer) {
            vector<string> merged_account;
            merged_account.push_back(accounts[account_to_idx[root]][0]);
            // Set 會自己排序。
            merged_account.insert(merged_account.end(), account_set.begin(), account_set.end());
            answer.push_back(merged_account);
        }

        return answer;
    }
};

# email 對應到第幾個資料
account_to_idx = {}
boss = {}
rank = defaultdict(lambda: 0)
# 這裡插入 DSU 模板 code
# 開始合併。
for i, account_list in enumerate(accounts):
  for account in account_list[1:]:
    account_to_idx[account] = i
    if account not in boss:
      boss[account] = account
    merge(account_list[1], account)

pre_answer = defaultdict(lambda: set())
# 開始統整答案
for i, account_list in enumerate(accounts):
  for account in account_list[1:]:
    boss_name_idx = account_to_idx[find_boss(account)]
    pre_answer[boss_name_idx].add(account)

return [ [accounts[i][0]] + sorted(list(l)) for i, l in pre_answer.items()]

#########
#.......#
#.#####.#
#.......#
##.#.####
#..#.#..#
#.##.##.#
#.......#
#########

#########
#1......#
#2#####.#
#3456...#
##.#7####
#..#8#..#
#.##9##.#
#...ABCD#
#########

#########
#.......#
#.#.###.#
#...###.#
#######.#
#######.#
#######.#
#######.#
#########

#include <iostream>
#include <vector>
using namespace std;
char table[101][101];
int ix[] = {1, 0, -1, 0};
int iy[] = {0, 1, 0, -1};
vector<pair<int, int>> Q[10000];
int main(){
    int n, ans=-1;
    scanf("%d", &n);
    for(int i=0; i<n; i++)
        scanf("%s", table[i]);

    Q[0].push_back({1, 1});
    for(int cur_cost=0; !Q[cur_cost].empty(); cur_cost++){
        for (auto &[x, y] : Q[cur_cost]) {
            if(x == n-2 && y == n-2) {
                printf("%d\n", cur_cost+1);
                return 0;
            }
            for(int k=0; k<4; k++){
                int nx = x + ix[k], ny = y + iy[k];
                if(table[nx][ny] == '.'){
                    Q[cur_cost+1].push_back({nx, ny});
                    table[nx][ny] = '#';
                }
            }
        }
    }
    printf("No solution!");
    return 0;
}

from collections import defaultdict
DIRS = [[0, 1], [0, -1], [1, 0], [-1, 0]]
n = int(input())
maze = [input() for _ in range(n)]
Q = defaultdict(list)
Q[0].append((1, 1))

cur_cost = 0
visit = set()
answer = None
while Q[cur_cost] and answer is None:
    for x, y in Q[cur_cost]:
        # If it's answer, break
        if x == n-2 and y == n-2:
            answer = cur_cost
            break
        # If visit, skip
        if (x, y) in visit:
            continue
        visit.add((x, y))
        # Search next states
        for dx, dy in DIRS:
            nx, ny = x + dx, y + dy
            if maze[nx][ny] == '.':
                Q[cur_cost+1].append((nx, ny))
    cur_cost += 1
if answer is None:
    print("No solution!")
else:
    print(answer + 1)

#include <iostream>
#include <queue>
using namespace std;
char table[101][101];
int cost[101][101];
int ix[] = {1, 0, -1, 0};
int iy[] = {0, 1, 0, -1};
int main(){
    int n, ans=-1;
    scanf("%d", &n);
    for(int i=0; i<n; i++)
        scanf("%s", table[i]);
    
    queue<pair<int, int> > Q({{1, 1}});
    while(!Q.empty()){
        auto now = Q.front();
        Q.pop();
        if(now.first == n-2 && now.second == n-2){
            printf("%d\n", cost[n-2][n-2]+1);
            return 0;
        }
        for(int k=0; k<4; k++){
            int nx = now.first + ix[k];
            int ny = now.second + iy[k];
            if(table[nx][ny] == '.'){
                cost[nx][ny] = cost[now.first][now.second] + 1;
                Q.push({nx, ny});
                table[nx][ny] = '#';
            }
        }
    }
    printf("No solution!");
    return 0;
}

#include <iostream>
#include <queue>
using namespace std;
char table[101][101];
int ix[] = {1, 0, -1, 0};
int iy[] = {0, 1, 0, -1};
int main(){
    int n, ans=-1;
    scanf("%d", &n);
    for(int i=0; i<n; i++)
        scanf("%s", table[i]);
    
    queue<vector<int> > Q({{1, 1, 1}});
    while(!Q.empty()){
        auto tmp = Q.front();
        int x = tmp[0], y = tmp[1], cost = tmp[2];
        Q.pop();
        if(x == n-2 && y == n-2){
            printf("%d\n", cost);
            return 0;
        }
        for(int k=0; k<4; k++){
            int nx = x + ix[k], ny = y + iy[k];
            if(table[nx][ny] == '.'){
                Q.push({nx, ny, cost+1});
                table[nx][ny] = '#';
            }
        }
    }
    printf("No solution!");
    return 0;
}

from collections import deque
DIRS = [[0, 1], [0, -1], [1, 0], [-1, 0]]
n = int(input())
maze = [input() for _ in range(n)]
# Starts at (1, 1) with cost 1
Q = deque([(1, 1, 1)])

visit = set()
answer = None
while Q:
    x, y, cost = Q.popleft()
    # If gets answer, break
    if x == n-2 and y == n-2:
        answer = cost
        break
    # If visit, skip
    if (x, y) in visit:
        continue
    visit.add((x, y))
    # Search next states
    for dx, dy in DIRS:
        nx, ny = x + dx, y + dy
        if maze[nx][ny] == '.':
            Q.append((nx, ny, cost+1))
if answer is None:
    print("No solution!")
else:
    print(answer)

11000
11000
00100
00011

11110
11010
11000
00000

vector<char> getPossibilities(vector<vector<char>>& board, int x, int y) {
  bool visit[256] = {};
  for (int i=0; i<9; i++) {
    visit[board[i][y]] = true;
    visit[board[x][i]] = true;
    visit[board[x/3*3 + i/3][y/3*3 + i%3]] = true;
  }
  vector<char> V;
  for (char c='1'; c<='9'; c++)
    if (!visit[c])
      V.push_back(c);
  return V;
}

def getPossibilities(self, board: List[List[str]], x: int, y: int) -> bool:
  possibles = set('123456789')
  for i in range(9):
    possibles.discard(board[i][y])
    possibles.discard(board[x][i])
    possibles.discard(board[x//3*3 + i//3][y//3*3 + i%3])
  return possibles

bool solveSudoku(vector<vector<char>>& board, int start=0) {
  if (start == 81)
  	return true;
  int x = start / 9, y = start % 9;
  if (board[x][y] != '.')
  	return solveSudoku(board, start+1);
  for (char guess : getPossibilities(board, x, y)) {
  	board[x][y] = guess;
  	if (solveSudoku(board, start+1))
  		return true;
  	board[x][y] = '.';
  }
  return false;
}

def solveSudoku(self, board: List[List[str]], start=0) -> None:
  if start == 81:
    return True
  x, y = start // 9, start % 9
  if board[x][y] != '.':
    return self.solveSudoku(board, start+1)
  else:
    for guess in self.getPossibilities(board, x, y):
      board[x][y] = guess
      if self.solveSudoku(board, start+1):
        return True
      board[x][y] = '.'
    return False 

def isEnd(self, board):
  return board == [[1, 2, 3], [4, 5, 0]]

def getPossibilities(self, board):
  # Find Zero
  x, y = [(i, j) for i in range(2) for j in range(3) if board[i][j] == 0][0]
  possibilities = []
  for dx, dy in [[1, 0], [-1, 0], [0, 1], [0, -1]]:
    nx, ny = x + dx, y + dy
    if not (0 <= nx <= 1 and 0 <= ny <= 2):
      continue
    nxt_board = deepcopy(board)
    nxt_board[x][y], nxt_board[nx][ny] = nxt_board[nx][ny], nxt_board[x][y]
    possibilities.append(nxt_board)
  return possibilities

def slidingPuzzle(self, board: List[List[int]]) -> int:
    Q = deque([(board, 0)])
    visit = set()
    while Q:
        cur_board, cost = Q.popleft()
        if self.isEnd(cur_board):
            return cost
        key = str(cur_board)
        if key in visit:
        	continue
        visit.add(key)
		for nxt_board in self.getPossibilities(cur_board):
            Q.append((nxt_board, cost+1))                    
    return -1

#include <iostream>
#include <unordered_set>
#include <set>
using namespace std;

struct A {
    int x;
    bool operator <(const A &other) const {
        return x < other.x;
    }
};

struct B {
    int x;
    bool operator ==(const B &other) const {
        return x == other.x;
    }
};

namespace std {
    template<> struct hash<B> {
        size_t operator()(const B& p) const noexcept {
            return p.x;
        }
    };
}

int main() {
    set<A> S1;
    S1.insert(A());

    unordered_set<B> S2;
    S2.insert(B());

}

class A:
    def __init__(self):
        self.x = 0

    def __eq__(self, value: object) -> bool:
        return self.x == value.x

    def __hash__(self) -> int:
        return self.x
    

print(len({A(), A()}))

char tree[] = "ABEDFCG";

int x = 1;
printf("Node %d: %c", x, tree[x]);

int x_l = 2*x+1;
printf("L %d: %c", x_l, tree[x_l]);

int x_r = 2*x+2;
printf("R %d: %c", x_r, tree[x_r]);

tree = "ABEDFCG"

x = 1
print(f"Node {x}: {tree[x]}")

x_l = 2*x+1
print(f"L {x_l}: {tree[x_l]}")

x_r = 2*x+2
print(f"R {x_r}: {tree[x_r]}")

struct Tree {
	char data;
	Tree *l, *r;
    Tree (char d, Tree *l, Tree *r):
      data(d), l(l), r(r) {}
};

class Tree:
    def __init__(self, d, l, r):
        self.data = d
        self.l = l
        self.r = r

#include <stdio.h>
struct Tree {
	char data;
	Tree *l, *r;
    Tree (char d, Tree *l, Tree *r):
      data(d), l(l), r(r) {}
};
int main() {
    Tree *root = new Tree('A',
        new Tree('B', 
            new Tree('D', NULL, NULL),
            new Tree('F', NULL, NULL)
        ),
        new Tree('E', 
            new Tree('C', NULL, NULL),
            new Tree('G', NULL, NULL)
        )
    );
    printf("%c\n", root->l->r->data); // F
    printf("%c\n", root->r->l->data); // C
}

class Tree:
    def __init__(self, d, l, r):
        self.data = d
        self.l = l
        self.r = r

root = Tree('A', 
        Tree('B', 
            Tree('D', None, None), 
            Tree('F', None, None)),
        Tree('E', 
            Tree('C', None, None), 
            Tree('G', None, None))
)

print(root.l.r.data)	# F
print(root.r.l.data)	# C

queue<Tree *> Q({root});
while (!Q.empty()) {
    Tree *cur = Q.front();
    Q.pop();
    printf("-> %c ", cur->data);
    if (cur->l) Q.push(cur->l);
    if (cur->r) Q.push(cur->r);
}

-> A -> B -> E -> D -> F -> C -> G 

Q = deque([root])
while Q:
    cur = Q.popleft()
    print(" ->", cur.data, end='')
    if cur.l: Q.append(cur.l)
    if cur.r: Q.append(cur.r)

void dfs(Tree *root) {
    if (!root)  return;
    printf("-> %c ", root->data);
    dfs(root->l);
    dfs(root->r);
}

-> A -> B -> D -> F -> E -> C -> G

def dfs(root):
    if root:
        print(" ->", root.data, end='')
        dfs(root.l)
        dfs(root.r)

int maxDepth(TreeNode* root) {
    if (!root) return 0;
    return 1 + max(
        maxDepth(root->left), 
        maxDepth(root->right));
}

def maxDepth(self, root):
    if root is None:
        return 0
    return 1 + max(
        self.maxDepth(root.left),
        self.maxDepth(root.right))