Problem

Given a permutation of length $ N $ $ P = \\ {P_1, P_2, \ ldots, P_N \\} $ and the integer $ K $.
Determine if the permutation $ P $ can be monotonically increased by repeating the following operation any number of times $ 0 $ or more.

* Choose the integer $ x \ (0 \ le x \ le N-K) $. Patrol right shift around $ P_ {x + 1}, \ ldots, P_ {x + K} $



However, the cyclic right shift of the subsequence $ U = U_1, \ ldots, U_M $ means that $ U = U_1, \ ldots, U_M $ is changed to $ U = U_M, U_1, \ ldots, U_ {M-1} $. Means to change.

Constraints

The input satisfies the following conditions.

* $ 2 \ leq K \ leq N \ leq 10 ^ 5 $
* $ 1 \ leq P_i \ leq N \ (1 \ leq i \ leq N) $
* $ P_i \ neq P_j \ (i \ neq j) $
* All inputs are integers

Input

The input is given in the following format.


$ N $ $ K $
$ P_1 $ $ \ ldots $ $ P_N $


Permutation length $ N $ and integer $ K $ are given in the first row, separated by blanks.
The elements of the permutation $ P $ are given in the second row, separated by blanks.

Output

Print "Yes" if you can monotonically increase $ P $, otherwise print "No" on the $ 1 $ line.

Examples

Input

3 3
2 3 1


Output

Yes


Input

3 2
1 2 3


Output

Yes


Input

3 3
3 2 1


Output

No
#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <climits>
#include <cmath>
#include <complex>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <cstdint>
using namespace std;
typedef long long ll;
#define MP make_pair
#define PB push_back
#define inf 1000000007
#define mod 1000000007
#define rep(i,n) for(int i = 0; i < (int)(n); ++i)
set<vector<int> > st;

void dfs(vector<int> a,int n,int k){
    for(int i=0;i<=n-k;i++){
        for(int t = 1;t<=k-1;t++){
            vector<int>b(n);
            rep(j,n){
                b[j] = a[j];
            }  
        
            rep(j,k){
                b[i+j] = a[i+j+t];
                if(i+j+t >= i+k){
                    b[i+j] = a[i+j+t-k];
                } 
            }
            if(st.count(b)){

            }else{
                st.insert(b);
                dfs(b,n,k);
            }
        }
    }

}
template<typename T> class BIT {
private:
	int n;
	vector<T> bit;
public:
	// 0_indexed で i 番目の要素に x を加える
	void add(int i, T x){
		i++;
		while(i < n){
			bit[i] += x, i += i & -i;
		}
	}
	// 0_indexed で [0,i] の要素の和(両閉区間！！)
	T sum(int i){
		i++;
		T s = 0;
		while(i > 0){
			s += bit[i], i -= i & -i;
		}
		return s;
	}
	BIT(){}
	//初期値がすべて0の場合
	BIT(int sz) : n(sz+1), bit(n, 0){}
	BIT(const vector<T>& v) : n((int)v.size()+1), bit(n, 0){
		for(int i = 0; i < n-1; i++){
			add(i,v[i]);
		}
	}
	void print(){
		for(int i = 0; i < n-1; i++){
			cout << sum(i) - sum(i-1) << " ";
		}
		cout << "\n";
	}
	//-1スタート
	void print_sum(){
		for(int i = 0; i < n; i++){
			cout << sum(i-1) << " ";
		}
		cout << "\n";
	}
};
 
// u を昇順にソートするのに必要な交換回数(転倒数) (u は {0,..., n-1} からなる重複を許した長さ n の数列)
long long inv_count(const vector<int>& u)
{
	int n = (int)u.size();
	BIT<int> bt(n);
	long long ans = 0;
	for(int i = 0; i < n; i++){
		ans += i - bt.sum(u[i]);
		bt.add(u[i], 1);
	}
	return ans;
}
 
// u を v に変換するのに必要な交換回数(転倒数)
// (u, v は {0,..., n-1} からなる重複を許した長さ n の数列. ただし u, v 全体で各数字の個数は一致するものとする)
long long inv_count(const vector<int>& u, const vector<int>& v)
{
    int n = (int)u.size();
    vector<vector<int> > p(n);
    BIT<int> bt(n);
    for(int i = n-1; i >= 0; --i){
        p[u[i]].push_back(i);
    }
    long long ans = 0;
    for(int i = 0; i < n; ++i){
        int pos = p[v[i]].back();
        p[v[i]].pop_back();
        ans += pos - bt.sum(pos);
        bt.add(pos, 1);
    }
    return ans;
}
int main(){
    // for(int n = 2;n<=8;n++){
    //     for(int k=2;k<=n;k++){
    //         st.clear();
    //         vector<int>v(n);
    //         rep(i,n){
    //             v[i] = i;
    //         }
    //         dfs(v,n,k);
    //         int sm = 1;
    //         rep(i,n){
    //             sm *=(i+1);
    //         }
    //         cout << n << " " << k << endl;
    //         cout << sm << endl;
    //         cout << st.size() << endl;
    //         // for(auto s:st){
    //         //     for(auto x:s){
    //         //         cout << x << " ";
    //         //     }
    //         //     cout << endl;
    //         // }
    //     }
    // }
    int n,k;
    cin >> n >> k;
    vector<int>a(n);
    rep(i,n){
        cin >> a[i];
        a[i]--;
    }
    if(n==k){
        int id = 0;
        rep(i,n){
            if(a[i]==0){
                id = i;
            }
        }
        rep(i,n){
            int k = id+i;
            k%=n;
            
            if(a[k]!=i){
                cout <<"No" << endl;
                return 0;
            }
        }
        cout << "Yes" << endl;
    }else{
        if(k%2==0){
            cout << "Yes" << endl;
        }else{
            if(inv_count(a)%2){
                cout << "No" << endl;
            }else{
                cout << "Yes" << endl;
            }
        }
    }
    return 0;
}
