#include <bits/stdc++.h>
#pragma GCC optimize(2)
const int mod = 1000;
const int maxn = 1e6 + 5;
const long long INF = 100000000000005;
using namespace std;
long long n, m, p;
int head[maxn];
int head1[maxn];
long long cnt = 0, cnt1 = 0;
struct node {
  int e, next;
} edge[maxn], edge1[maxn];
int dfn[maxn], low[maxn];
int st[maxn], s = 0;
int sct[maxn], szsc[maxn], scc = 0;
int inst[maxn];
int cot = 0;
int res[maxn];
int in[maxn];
int vis[maxn];
void addedge1(int u, int v) {
  edge1[cnt1].e = v;
  edge1[cnt1].next = head1[u];
  head1[u] = cnt1++;
}
void addedge(int u, int v) {
  edge[cnt].e = v;
  edge[cnt].next = head[u];
  head[u] = cnt++;
}
void Tarjan(int u) {
  st[++s] = u;
  inst[u] = 1;
  low[u] = dfn[u] = ++cot;
  for (int i = head[u]; ~i; i = edge[i].next) {
    int e = edge[i].e;
    if (!dfn[e]) {
      Tarjan(e);
      low[u] = min(low[u], low[e]);
    } else if (inst[e])
      low[u] = min(low[u], dfn[e]);
  }
  if (low[u] == dfn[u]) {
    scc++;
    while (1) {
      int x = st[s--];
      inst[x] = 0;
      sct[x] = scc;
      if (x == u) break;
    }
  }
}
void To_order() {
  int z = 0;
  queue<int> q;
  for (int i = 1; i <= scc; i++)
    if (!in[i]) q.push(i);
  while (!q.empty()) {
    int u = q.front();
    q.pop();
    if (z < m - 1)
      res[u] = z++;
    else
      res[u] = z;
    for (int i = head1[u]; ~i; i = edge1[i].next) {
      int e = edge1[i].e;
      in[e]--;
      if (!in[e]) q.push(e);
    }
  }
  printf("YES\n");
  for (int i = 1; i <= n; i++) {
    char ch = res[sct[i]] + 'a';
    printf("%c", ch);
  }
  printf("\n");
}
long long a[maxn];
long long b[maxn];
int main() {
  memset(head, -1, sizeof(head));
  memset(head1, -1, sizeof(head1));
  scanf("%lld%lld", &n, &m);
  for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
  for (int i = 1; i <= n; i++) scanf("%lld", &b[i]);
  for (int i = 1; i <= n - 1; i++) {
    addedge(a[i], a[i + 1]);
    addedge(b[i], b[i + 1]);
  }
  for (int i = 1; i <= n; i++)
    if (!dfn[i]) Tarjan(i);
  for (int i = 1; i <= n; i++) {
    for (int k = head[i]; ~k; k = edge[k].next) {
      int e = edge[k].e;
      if (sct[i] != sct[e]) {
        addedge1(sct[i], sct[e]);
        in[sct[e]]++;
      }
    }
  }
  if (m > scc)
    printf("NO\n");
  else
    To_order();
}

### Prompt

In Cpp, your task is to solve 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>
#pragma GCC optimize(2)
const int mod = 1000;
const int maxn = 1e6 + 5;
const long long INF = 100000000000005;
using namespace std;
long long n, m, p;
int head[maxn];
int head1[maxn];
long long cnt = 0, cnt1 = 0;
struct node {
  int e, next;
} edge[maxn], edge1[maxn];
int dfn[maxn], low[maxn];
int st[maxn], s = 0;
int sct[maxn], szsc[maxn], scc = 0;
int inst[maxn];
int cot = 0;
int res[maxn];
int in[maxn];
int vis[maxn];
void addedge1(int u, int v) {
  edge1[cnt1].e = v;
  edge1[cnt1].next = head1[u];
  head1[u] = cnt1++;
}
void addedge(int u, int v) {
  edge[cnt].e = v;
  edge[cnt].next = head[u];
  head[u] = cnt++;
}
void Tarjan(int u) {
  st[++s] = u;
  inst[u] = 1;
  low[u] = dfn[u] = ++cot;
  for (int i = head[u]; ~i; i = edge[i].next) {
    int e = edge[i].e;
    if (!dfn[e]) {
      Tarjan(e);
      low[u] = min(low[u], low[e]);
    } else if (inst[e])
      low[u] = min(low[u], dfn[e]);
  }
  if (low[u] == dfn[u]) {
    scc++;
    while (1) {
      int x = st[s--];
      inst[x] = 0;
      sct[x] = scc;
      if (x == u) break;
    }
  }
}
void To_order() {
  int z = 0;
  queue<int> q;
  for (int i = 1; i <= scc; i++)
    if (!in[i]) q.push(i);
  while (!q.empty()) {
    int u = q.front();
    q.pop();
    if (z < m - 1)
      res[u] = z++;
    else
      res[u] = z;
    for (int i = head1[u]; ~i; i = edge1[i].next) {
      int e = edge1[i].e;
      in[e]--;
      if (!in[e]) q.push(e);
    }
  }
  printf("YES\n");
  for (int i = 1; i <= n; i++) {
    char ch = res[sct[i]] + 'a';
    printf("%c", ch);
  }
  printf("\n");
}
long long a[maxn];
long long b[maxn];
int main() {
  memset(head, -1, sizeof(head));
  memset(head1, -1, sizeof(head1));
  scanf("%lld%lld", &n, &m);
  for (int i = 1; i <= n; i++) scanf("%lld", &a[i]);
  for (int i = 1; i <= n; i++) scanf("%lld", &b[i]);
  for (int i = 1; i <= n - 1; i++) {
    addedge(a[i], a[i + 1]);
    addedge(b[i], b[i + 1]);
  }
  for (int i = 1; i <= n; i++)
    if (!dfn[i]) Tarjan(i);
  for (int i = 1; i <= n; i++) {
    for (int k = head[i]; ~k; k = edge[k].next) {
      int e = edge[k].e;
      if (sct[i] != sct[e]) {
        addedge1(sct[i], sct[e]);
        in[sct[e]]++;
      }
    }
  }
  if (m > scc)
    printf("NO\n");
  else
    To_order();
}

```