You are given n distinct points on a plane with integral coordinates. For each point you can either draw a vertical line through it, draw a horizontal line through it, or do nothing.

You consider several coinciding straight lines as a single one. How many distinct pictures you can get? Print the answer modulo 10^9 + 7.


-----Input-----

The first line contains single integer n (1 ≤ n ≤ 10^5) — the number of points.

n lines follow. The (i + 1)-th of these lines contains two integers x_{i}, y_{i} ( - 10^9 ≤ x_{i}, y_{i} ≤ 10^9) — coordinates of the i-th point.

It is guaranteed that all points are distinct.


-----Output-----

Print the number of possible distinct pictures modulo 10^9 + 7.


-----Examples-----
Input
4
1 1
1 2
2 1
2 2

Output
16

Input
2
-1 -1
0 1

Output
9



-----Note-----

In the first example there are two vertical and two horizontal lines passing through the points. You can get pictures with any subset of these lines. For example, you can get the picture containing all four lines in two ways (each segment represents a line containing it). The first way:   [Image]   The second way:   [Image] 

In the second example you can work with two points independently. The number of pictures is 3^2 = 9.

Difficulty: HARD

Solutions:
import sys
from math import *

def pro():
	return sys.stdin.readline().strip()

def rop():
	return map(int, pro().split())
z = int(pro())
qwe = 1000000007
a = [0] * z
x = {}
y = {}
for i in range(z):
	s = tuple(rop())
	a[i] = s
	if s[0] in x:
		x[s[0]].append(i)
	else:
		x[s[0]] = [i]
	if s[1] in y:
		y[s[1]].append(i)
	else:
		y[s[1]] = [i]
del pow
r = 1
q = [0] * z
w = [True] * z
o = 0
po = 0
for i in range(z):
	if w[i]:
		w[i] = False
		q[po] = i
		po += 1
		poi = o
		e = 0
		xs = set()
		ys = set()
		while o < po:
			v = q[o]
			o += 1
			s = a[v]
			if s[0] not in xs:
				xs.add(s[0])
				e -= 1
				for u in x[s[0]]:
					e += 1
					if w[u]:
						w[u] = False
						q[po] = u
						po += 1
			if s[1] not in ys:
				ys.add(s[1])
				e -= 1
				for u in y[s[1]]:
					e += 1
					if w[u]:
						w[u] = False
						q[po] = u
						po += 1
		vc = o - poi
		if vc - 1 == e:
			r = r * (pow(2, vc + 1, qwe) - 1) % qwe
		else:
			r = r * pow(2, len(xs) + len(ys), qwe) % qwe
print(r)


n = int(input())
disjointSet = [-1] * n

def root(x, level=200):
	dp = []
	while disjointSet[x] >= 0:
		dp.append(x)
		x = disjointSet[x]
	for i in dp:
		disjointSet[i] = x
	return x

def join(x, y):
	(r1, r2) = (root(x), root(y))
	if r1 == r2:
		return
	disjointSet[r2] = r1
points = []
vertPoints = {}
horizPoints = {}
for i in range(n):
	(a, b) = map(int, input().split())
	points.append((a, b))
	if a in vertPoints:
		join(i, vertPoints[a])
	else:
		vertPoints[a] = i
	if b in horizPoints:
		join(i, horizPoints[b])
	else:
		horizPoints[b] = i
sets = {}
for i in range(n):
	r = root(i)
	if r in sets:
		sets[r].append(points[i])
	else:
		sets[r] = [points[i]]
ans = 1
for i in sets:
	s = sets[i]
	horiz = [x for (x, y) in s]
	vert = [y for (x, y) in s]
	tmp = len(set(horiz)) + len(set(vert))
	if tmp <= len(s):
		ans *= 2 ** tmp
	else:
		ans *= 2 ** tmp - 1
	ans %= 10 ** 9 + 7
print(ans % (10 ** 9 + 7))


import sys
from math import *

def minp():
	return sys.stdin.readline().strip()

def mint():
	return int(minp())

def mints():
	return map(int, minp().split())
n = mint()
p = [0] * n
x = dict()
y = dict()
for i in range(n):
	a = tuple(mints())
	p[i] = a
	if a[0] in x:
		x[a[0]].append(i)
	else:
		x[a[0]] = [i]
	if a[1] in y:
		y[a[1]].append(i)
	else:
		y[a[1]] = [i]
del pow
r = 1
q = [0] * n
w = [True] * n
ql = 0
qr = 0
for i in range(n):
	if w[i]:
		w[i] = False
		q[qr] = i
		qr += 1
		qlb = ql
		e = 0
		xs = set()
		ys = set()
		while ql < qr:
			v = q[ql]
			ql += 1
			a = p[v]
			if a[0] not in xs:
				xs.add(a[0])
				e -= 1
				for u in x[a[0]]:
					e += 1
					if w[u]:
						w[u] = False
						q[qr] = u
						qr += 1
			if a[1] not in ys:
				ys.add(a[1])
				e -= 1
				for u in y[a[1]]:
					e += 1
					if w[u]:
						w[u] = False
						q[qr] = u
						qr += 1
		vc = ql - qlb
		if vc - 1 == e:
			r = r * (pow(2, vc + 1, 1000000007) - 1) % 1000000007
		else:
			r = r * pow(2, len(xs) + len(ys), 1000000007) % 1000000007
print(r)