1503_D. Flip the Cards
There is a deck of n cards. The i-th card has a number a_i on the front and a number b_i on the back. Every integer between 1 and 2n appears exactly once on the cards.

A deck is called sorted if the front values are in increasing order and the back values are in decreasing order. That is, if a_i< a_{i+1} and b_i> b_{i+1} for all 1≤ i<n.

To flip a card i means swapping the values of a_i and b_i. You must flip some subset of cards (possibly, none), then put all the cards in any order you like. What is the minimum number of cards you must flip in order to sort the deck?

Input

The first line contains a single integer n (1≤ n≤ 2⋅ 10^5) — the number of cards.

The next n lines describe the cards. The i-th of these lines contains two integers a_i, b_i (1≤ a_i, b_i≤ 2n). Every integer between 1 and 2n appears exactly once.

Output

If it is impossible to sort the deck, output "-1". Otherwise, output the minimum number of flips required to sort the deck.

Examples

Input


5
3 10
6 4
1 9
5 8
2 7


Output


2


Input


2
1 2
3 4


Output


-1


Input


3
1 2
3 6
4 5


Output


-1

Note

In the first test case, we flip the cards (1, 9) and (2, 7). The deck is then ordered (3,10), (5,8), (6,4), (7,2), (9,1). It is sorted because 3<5<6<7<9 and 10>8>4>2>1.

In the second test case, it is impossible to sort the deck.
```python
import sys
input = sys.stdin.readline

n = int(input())

front = [-1] * n
back = [-1] * n
rev = [-1] * (2 * n)
used = [False] * n
opp = [-1] * (2 * n)

for c in range(n):
    a, b = map(lambda x: int(x) - 1, input().split())
    front[c] = a
    back[c] = b
    rev[a] = c
    rev[b] = c
    opp[a] = b
    opp[b] = a


left = -1
right = 2 * n
out = 0
works = True
while right - left > 1:
    s_l = left + 1
    s_r = right
    curr = 0
    curr_f = 0

    while (s_l > left or s_r < right) and right - left > 1:
        #print(left, s_l, s_r, right)
        if s_l > left:
            left += 1
            card = rev[left]
            if not used[card]:
                used[card] = True
                curr += 1
                if front[card] == left:
                    curr_f += 1
                if opp[left] < s_r:
                    s_r = opp[left]
                else:
                    works = False
        elif s_r < right:
            right -= 1
            card = rev[right]
            if not used[card]:
                used[card] = True
                curr += 1
                if front[card] == right:
                    curr_f += 1
                if opp[right] > s_l:
                    s_l = opp[right]
                else:
                    works = False
    if s_l > s_r:
        works = False
    if not works:
        break
    out += min(curr_f, curr - curr_f)

if works:
    print(out)
else:
    print(-1)

    

```