#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const double Pi = 3.1415926535897932;
const int maxn = 2e5 + 5;
int P[maxn];
vector<int> G[maxn], G1[maxn];
int dfn[maxn], low[maxn];
int id;
int color;
int belong[maxn];
int in[maxn];
bool ins[maxn];
stack<int> st;
int n, m;
int f[maxn];
void solve();
void tarjan(int a);
bool topsort();
int main() {
  scanf("%d%d", &n, &m);
  for (int i = 1; i <= 2; i++) {
    for (int j = 1; j <= n; j++) scanf("%d", &P[j]);
    for (int j = 1; j < n; j++) G[P[j]].push_back(P[j + 1]);
  }
  solve();
  if (topsort()) {
    printf("YES\n");
    for (int i = 1; i <= n; i++) putchar('a' + min(f[belong[i]], m - 1));
    putchar(10);
  } else
    printf("NO\n");
  return 0;
}
void solve() {
  id = color = 0;
  for (int i = 1; i <= n; i++) {
    if (!dfn[i]) tarjan(i);
  }
  for (int i = 1; i <= n; i++) {
    const int &a = belong[i];
    for (int j = 0; j < G[i].size(); j++) {
      const int &b = belong[G[i][j]];
      if (a != b) {
        G1[a].push_back(b);
        in[b]++;
      }
    }
  }
}
void tarjan(int a) {
  dfn[a] = low[a] = ++id;
  st.push(a);
  ins[a] = true;
  for (int i = 0; i < G[a].size(); i++) {
    const int &b = G[a][i];
    if (!dfn[b]) {
      tarjan(b);
      low[a] = min(low[a], low[b]);
    } else if (ins[b])
      low[a] = min(low[a], low[b]);
  }
  if (dfn[a] == low[a]) {
    color++;
    int b;
    do {
      b = st.top();
      st.pop();
      ins[b] = false;
      belong[b] = color;
    } while (b != a);
  }
}
bool topsort() {
  while (!st.empty()) st.pop();
  for (int i = 1; i <= color; i++) {
    if (!in[i]) {
      st.push(i);
      f[i] = 0;
    }
  }
  int mx = -1;
  while (!st.empty()) {
    int a = st.top();
    st.pop();
    mx = max(mx, f[a]);
    for (int i = 0; i < G1[a].size(); i++) {
      const int &b = G1[a][i];
      f[b] = max(f[b], f[a] + 1);
      in[b]--;
      if (!in[b]) st.push(b);
    }
  }
  return mx + 1 >= m;
}

### Prompt

Please create a solution in cpp to the following problem:

Authors have come up with the string s consisting of n lowercase Latin letters.

You are given two permutations of its indices (not necessary equal) p and q (both of length n). Recall that the permutation is the array of length n which contains each integer from 1 to n exactly once.

For all i from 1 to n-1 the following properties hold: s[p_i] ≤ s[p_{i + 1}] and s[q_i] ≤ s[q_{i + 1}]. It means that if you will write down all characters of s in order of permutation indices, the resulting string will be sorted in the non-decreasing order.

Your task is to restore any such string s of length n consisting of at least k distinct lowercase Latin letters which suits the given permutations.

If there are multiple answers, you can print any of them.

Input

The first line of the input contains two integers n and k (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k ≤ 26) — the length of the string and the number of distinct characters required.

The second line of the input contains n integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ n, all p_i are distinct integers from 1 to n) — the permutation p.

The third line of the input contains n integers q_1, q_2, ..., q_n (1 ≤ q_i ≤ n, all q_i are distinct integers from 1 to n) — the permutation q.

Output

If it is impossible to find the suitable string, print "NO" on the first line.

Otherwise print "YES" on the first line and string s on the second line. It should consist of n lowercase Latin letters, contain at least k distinct characters and suit the given permutations.

If there are multiple answers, you can print any of them.

Example

Input


3 2
1 2 3
1 3 2


Output


YES
abb

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const double Pi = 3.1415926535897932;
const int maxn = 2e5 + 5;
int P[maxn];
vector<int> G[maxn], G1[maxn];
int dfn[maxn], low[maxn];
int id;
int color;
int belong[maxn];
int in[maxn];
bool ins[maxn];
stack<int> st;
int n, m;
int f[maxn];
void solve();
void tarjan(int a);
bool topsort();
int main() {
  scanf("%d%d", &n, &m);
  for (int i = 1; i <= 2; i++) {
    for (int j = 1; j <= n; j++) scanf("%d", &P[j]);
    for (int j = 1; j < n; j++) G[P[j]].push_back(P[j + 1]);
  }
  solve();
  if (topsort()) {
    printf("YES\n");
    for (int i = 1; i <= n; i++) putchar('a' + min(f[belong[i]], m - 1));
    putchar(10);
  } else
    printf("NO\n");
  return 0;
}
void solve() {
  id = color = 0;
  for (int i = 1; i <= n; i++) {
    if (!dfn[i]) tarjan(i);
  }
  for (int i = 1; i <= n; i++) {
    const int &a = belong[i];
    for (int j = 0; j < G[i].size(); j++) {
      const int &b = belong[G[i][j]];
      if (a != b) {
        G1[a].push_back(b);
        in[b]++;
      }
    }
  }
}
void tarjan(int a) {
  dfn[a] = low[a] = ++id;
  st.push(a);
  ins[a] = true;
  for (int i = 0; i < G[a].size(); i++) {
    const int &b = G[a][i];
    if (!dfn[b]) {
      tarjan(b);
      low[a] = min(low[a], low[b]);
    } else if (ins[b])
      low[a] = min(low[a], low[b]);
  }
  if (dfn[a] == low[a]) {
    color++;
    int b;
    do {
      b = st.top();
      st.pop();
      ins[b] = false;
      belong[b] = color;
    } while (b != a);
  }
}
bool topsort() {
  while (!st.empty()) st.pop();
  for (int i = 1; i <= color; i++) {
    if (!in[i]) {
      st.push(i);
      f[i] = 0;
    }
  }
  int mx = -1;
  while (!st.empty()) {
    int a = st.top();
    st.pop();
    mx = max(mx, f[a]);
    for (int i = 0; i < G1[a].size(); i++) {
      const int &b = G1[a][i];
      f[b] = max(f[b], f[a] + 1);
      in[b]--;
      if (!in[b]) st.push(b);
    }
  }
  return mx + 1 >= m;
}

```