Problem:
Score : 1200 points

Problem Statement

You are given a permutation of 1,2,...,N: p_1,p_2,...,p_N. Determine if the state where p_i=i for every i can be reached by performing the following operation any number of times:

Choose three elements p_{i-1},p_{i},p_{i+1} (2\leq i\leq N-1) such that p_{i-1}>p_{i}>p_{i+1} and reverse the order of these three.

Constraints

3 \leq N \leq 3 × 10^5

p_1,p_2,...,p_N is a permutation of 1,2,...,N.

Input

Input is given from Standard Input in the following format:

N
p_1
:
p_N

Output

If the state where p_i=i for every i can be reached by performing the operation, print Yes; otherwise, print No.

Sample Input 1

5
5
2
1
4
3

Sample Output 1

Yes

The state where p_i=i for every i can be reached as follows:

Reverse the order of p_1,p_2,p_3. The sequence p becomes 1,2,5,4,3.

Reverse the order of p_3,p_4,p_5. The sequence p becomes 1,2,3,4,5.

Sample Input 2

4
3
2
4
1

Sample Output 2

No

Sample Input 3

7
3
2
1
6
5
4
7

Sample Output 3

Yes

Sample Input 4

6
5
3
4
1
2
6

Sample Output 4

No

Solution in Ruby (2.3.3) (judge verdict: Wrong Answer)

def fail!
    puts 'No'
    exit
end

N = gets.to_i
ps = [0] + N.times.map{gets.to_i}
INF = 10**9

same = (0..N).map{|i| ps[i] == i}

blocks = []
pool = []
(1..N).each do |i|
    if same[i]
        if same[i-1] && pool.length > 0
            blocks.push(pool)
            pool = []
        end
    else
        if i > 1 && !same[i-1]
            unless i >= 4 && same[i-2] && !same[i-3]
                fail!
            end
            if pool.length > 0
                blocks.push(pool)
                pool = []
            end
        end
        pool.push(i)
    end
end
blocks.push(pool) if pool.length > 0

blocks.each do |bl|
    arr = []
    l, r = nil, nil
    min, max = INF, -INF
    bl.each do |e|
        arr.push(e)
        l ||= e
        r = e
        min = ps[e] if min > ps[e]
        max = ps[e] if max < ps[e]
        if min==l && max==r
            arr.length.times do |i|
                if ps[arr[i]] == l
                    l += 2
                    arr[i] = nil
                end
            end
            (arr.length-1).downto(0) do |i|
                if arr[i] && ps[arr[i]] == r
                    r -= 2
                end
            end
            if l - r != 2
                fail!
            end
            arr = []
            l, r = nil, nil
            min, max = INF, -INF
        end
    end
    fail! if arr.length > 0
end
puts 'Yes'