#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vpll = vector<pll>;
using vpdd = vector<pdd>;
template <typename T>
void ckmin(T& a, const T& b) {
  a = min(a, b);
}
template <typename T>
void ckmax(T& a, const T& b) {
  a = max(a, b);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
  cin >> x;
}
void re(double& x) {
  string t;
  re(t);
  x = stod(t);
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
  re(first);
  re(rest...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
  re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
  for (int i = 0; i < (int((a).size())); i++) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
  for (int i = 0; i < (SZ); i++) re(a[i]);
}
}  // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
  cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
  pr(first);
  pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
  pr("{", x.first, ", ", x.second, "}");
}
template <class T, bool pretty = true>
void prContain(const T& x) {
  if (pretty) pr("{");
  bool fst = 1;
  for (const auto& a : x) pr(!fst ? pretty ? ", " : " " : "", a), fst = 0;
  if (pretty) pr("}");
}
template <class T>
void pc(const T& x) {
  prContain<T, false>(x);
  pr("\n");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
  prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
  prContain(x);
}
template <class T>
void pr(const set<T>& x) {
  prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
  prContain(x);
}
void ps() { pr("\n"); }
template <class Arg>
void ps(const Arg& first) {
  pr(first);
  ps();
}
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
  pr(first, " ");
  ps(rest...);
}
}  // namespace __output
using namespace __output;
namespace __algorithm {
template <typename T>
void dedup(vector<T>& v) {
  sort((v).begin(), (v).end());
  v.erase(unique((v).begin(), (v).end()), v.end());
}
template <typename T>
typename vector<T>::const_iterator find(const vector<T>& v, const T& x) {
  auto it = lower_bound((v).begin(), (v).end(), x);
  return it != v.end() && *it == x ? it : v.end();
}
template <typename T>
size_t index(const vector<T>& v, const T& x) {
  auto it = find(v, x);
  assert(it != v.end() && *it == x);
  return it - v.begin();
}
template <typename T1, typename T2>
typename vector<pair<T1, T2>>::iterator lower_bound(
    const vector<pair<T1, T2>>& v, const T1& x) {
  return lower_bound(
      (v).begin(), (v).end(), x,
      [](pair<T1, T2> a, pair<T1, T2> b) { return a.first < b.first; });
}
template <typename T1, typename T2>
typename vector<pair<T1, T2>>::iterator upper_bound(
    const vector<pair<T1, T2>>& v, const T1& x) {
  return upper_bound(
      (v).begin(), (v).end(), x,
      [](pair<T1, T2> a, pair<T1, T2> b) { return a.first < b.first; });
}
}  // namespace __algorithm
using namespace __algorithm;
struct __monostate {
  friend istream& operator>>(istream& is,
                             const __attribute__((unused)) __monostate& ms) {
    return is;
  }
  friend ostream& operator<<(ostream& os,
                             const __attribute__((unused)) __monostate& ms) {
    return os;
  }
} ms;
namespace __io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout << setprecision(15);
  if (int((second).size())) {
    setIn(second + ".in"), setOut(second + ".out");
  }
}
}  // namespace __io
using namespace __io;
struct union_find_bipartite {
  struct node {
    int parent;
    int size = 1, root_status = -1, same_as_root = 1;
    bool root_path_parity = 0, consistent = 1;
    node(int id) : parent(id) {}
    int choices() const { return !consistent ? 0 : root_status == -1 ? 2 : 1; }
    int minimum_size() const {
      if (root_status == 1)
        return same_as_root;
      else if (root_status == 0)
        return size - same_as_root;
      return min(same_as_root, size - same_as_root);
    }
  };
  vector<node> uf;
  int components, bipartite_components, rank, minimum_size;
  union_find_bipartite(int N = 0)
      : components(N), bipartite_components(N), rank(N), minimum_size(0) {
    for (int v = 0; v < N; v++) {
      uf.emplace_back(v);
    }
  }
  int rep(int u) {
    if (uf[u].parent == u) return u;
    int root = rep(uf[u].parent);
    uf[u].root_path_parity ^= uf[uf[u].parent].root_path_parity;
    return uf[u].parent = root;
  }
  void subtract_component(int u) {
    components--;
    if (uf[u].consistent) {
      bipartite_components--;
      rank -= uf[u].root_status == -1;
      minimum_size -= uf[u].minimum_size();
    }
  }
  void add_component(int u) {
    components++;
    if (uf[u].consistent) {
      bipartite_components++;
      rank += uf[u].root_status == -1;
      minimum_size += uf[u].minimum_size();
    }
  }
  bool set_status(int u, bool u_status) {
    int u_root = rep(u);
    subtract_component(u_root);
    const bool implied_root_status = u_status ^ uf[u].root_path_parity;
    if (uf[u_root].root_status == -1) {
      uf[u_root].root_status = implied_root_status;
    } else if (uf[u_root].root_status != implied_root_status) {
      uf[u_root].consistent = false;
    }
    add_component(u_root);
    return uf[u_root].consistent;
  }
  struct result {
    bool added_connectivity, is_consistent;
  };
  result unite(int u, int v, bool edge_parity) {
    int u_root = rep(u), v_root = rep(v);
    if (u_root == v_root) {
      subtract_component(u_root);
      if (edge_parity != (uf[u].root_path_parity ^ uf[v].root_path_parity)) {
        uf[u_root].consistent = false;
      }
      add_component(u_root);
      return {false, uf[u_root].consistent};
    }
    edge_parity ^= uf[u].root_path_parity ^ uf[v].root_path_parity;
    u = u_root;
    v = v_root;
    if (uf[u].size < uf[v].size) swap(u, v);
    subtract_component(u), subtract_component(v);
    uf[v].parent = u;
    uf[v].root_path_parity = edge_parity;
    uf[u].size += uf[v].size;
    uf[u].consistent &= uf[v].consistent;
    if (edge_parity)
      uf[u].same_as_root += uf[v].size - uf[v].same_as_root;
    else
      uf[u].same_as_root += uf[v].same_as_root;
    if (uf[v].root_status != -1) {
      bool implied_u_status = uf[v].root_status ^ edge_parity;
      uf[u].consistent &=
          (uf[u].root_status == -1 || uf[u].root_status == implied_u_status);
      uf[u].root_status = implied_u_status;
    }
    add_component(u);
    return {true, uf[u].consistent};
  }
  result constrain_to_be_same(int u, int v) { return unite(u, v, 0); }
  result constrain_to_be_different(int u, int v) { return unite(u, v, 1); }
  bool is_consistent(int u, bool u_status) {
    int u_root = rep(u);
    if (!uf[u_root].consistent) return false;
    if (uf[u_root].root_status == -1) return true;
    return u_status == (uf[u].root_path_parity ^ uf[u_root].root_status);
  }
  bool is_consistent(int u, int v, bool edge_parity) {
    int u_root = rep(u), v_root = rep(v);
    if (!uf[u_root].consistent || !uf[v_root].consistent) {
      return false;
    } else if (u_root == v_root) {
      return edge_parity == (uf[u].root_path_parity ^ uf[v].root_path_parity);
    } else if (uf[u_root].root_status == -1 || uf[v_root].root_status == -1) {
      return true;
    } else {
      return (uf[u].root_path_parity ^ uf[u_root].root_status ^
              uf[v].root_path_parity ^ uf[v_root].root_status) == edge_parity;
    }
  }
};
int main() {
  setIO();
  int N, M;
  re(N, M);
  int n1, n2, n3;
  re(n1, n2, n3);
  array<int, 4> exp = {0, n1, n2, n3};
  union_find_bipartite ufb(N);
  vpii edges;
  bool ok = 1;
  for (int i = 0; i < (M); i++) {
    int u, v;
    re(u, v);
    --u, --v;
    edges.emplace_back(u, v);
    ok &= ufb.constrain_to_be_different(u, v).is_consistent;
  }
  if (!ok) {
    ps("NO");
    return 0;
  }
  vector<array<vi, 2>> comps(N);
  {
    for (int i = 0; i < (N); i++) {
      int p = ufb.rep(i);
      comps[p][ufb.uf[i].root_path_parity].push_back(i);
    }
    decltype(comps) tmp;
    for (auto& e : comps) {
      if (!e[0].empty() || !e[1].empty()) tmp.push_back(e);
    }
    comps = tmp;
  }
  int C = int((comps).size());
  vvi dp(C + 1, vi(N + 1, -1));
  dp[0][0] = 0;
  for (int i = 0; i < (C); i++) {
    for (int ct2 = 0; ct2 < (N + 1); ct2++)
      if (dp[i][ct2] != -1) {
        dp[i + 1][ct2 + int((comps[i][0]).size())] = 0;
        dp[i + 1][ct2 + int((comps[i][1]).size())] = 1;
      }
  }
  if (dp[C][n2] == -1) {
    ps("NO");
    return 0;
  }
  ps("YES");
  vi assign(N);
  int tmp = n2;
  for (int i = (C + 1) - 1; i >= (1); i--) {
    int inx = dp[i][tmp];
    for (auto& e : comps[i - 1][inx]) {
      assign[e] = 2;
      tmp--;
    }
  }
  for (auto& e : assign) {
    if (e == 2) continue;
    if (n1 > 0) {
      e = 1;
      n1--;
    } else {
      e = 3;
      n3--;
    }
  }
  array<int, 4> ct = {0, 0, 0, 0};
  for (auto& e : assign) ct[e]++;
  assert(ct == exp);
  for (auto& p : edges) {
    assert(abs(assign[p.first] - assign[p.second]) == 1);
  }
  for (auto& e : assign) pr(e);
  ps();
  return 0;
}

### Prompt

Please formulate a CPP solution to the following problem:

You are given an undirected graph without self-loops or multiple edges which consists of n vertices and m edges. Also you are given three integers n_1, n_2 and n_3.

Can you label each vertex with one of three numbers 1, 2 or 3 in such way, that: 

  1. Each vertex should be labeled by exactly one number 1, 2 or 3; 
  2. The total number of vertices with label 1 should be equal to n_1; 
  3. The total number of vertices with label 2 should be equal to n_2; 
  4. The total number of vertices with label 3 should be equal to n_3; 
  5. |col_u - col_v| = 1 for each edge (u, v), where col_x is the label of vertex x. 



If there are multiple valid labelings, print any of them.

Input

The first line contains two integers n and m (1 ≤ n ≤ 5000; 0 ≤ m ≤ 10^5) — the number of vertices and edges in the graph.

The second line contains three integers n_1, n_2 and n_3 (0 ≤ n_1, n_2, n_3 ≤ n) — the number of labels 1, 2 and 3, respectively. It's guaranteed that n_1 + n_2 + n_3 = n.

Next m lines contan description of edges: the i-th line contains two integers u_i, v_i (1 ≤ u_i, v_i ≤ n; u_i ≠ v_i) — the vertices the i-th edge connects. It's guaranteed that the graph doesn't contain self-loops or multiple edges.

Output

If valid labeling exists then print "YES" (without quotes) in the first line. In the second line print string of length n consisting of 1, 2 and 3. The i-th letter should be equal to the label of the i-th vertex.

If there is no valid labeling, print "NO" (without quotes).

Examples

Input


6 3
2 2 2
3 1
5 4
2 5


Output


YES
112323


Input


5 9
0 2 3
1 2
1 3
1 5
2 3
2 4
2 5
3 4
3 5
4 5


Output


NO

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;
using vvll = vector<vll>;
using vb = vector<bool>;
using vd = vector<double>;
using vs = vector<string>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vpii = vector<pii>;
using vpll = vector<pll>;
using vpdd = vector<pdd>;
template <typename T>
void ckmin(T& a, const T& b) {
  a = min(a, b);
}
template <typename T>
void ckmax(T& a, const T& b) {
  a = max(a, b);
}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
namespace __input {
template <class T1, class T2>
void re(pair<T1, T2>& p);
template <class T>
void re(vector<T>& a);
template <class T, size_t SZ>
void re(array<T, SZ>& a);
template <class T>
void re(T& x) {
  cin >> x;
}
void re(double& x) {
  string t;
  re(t);
  x = stod(t);
}
template <class Arg, class... Args>
void re(Arg& first, Args&... rest) {
  re(first);
  re(rest...);
}
template <class T1, class T2>
void re(pair<T1, T2>& p) {
  re(p.first, p.second);
}
template <class T>
void re(vector<T>& a) {
  for (int i = 0; i < (int((a).size())); i++) re(a[i]);
}
template <class T, size_t SZ>
void re(array<T, SZ>& a) {
  for (int i = 0; i < (SZ); i++) re(a[i]);
}
}  // namespace __input
using namespace __input;
namespace __output {
template <class T1, class T2>
void pr(const pair<T1, T2>& x);
template <class T, size_t SZ>
void pr(const array<T, SZ>& x);
template <class T>
void pr(const vector<T>& x);
template <class T>
void pr(const set<T>& x);
template <class T1, class T2>
void pr(const map<T1, T2>& x);
template <class T>
void pr(const T& x) {
  cout << x;
}
template <class Arg, class... Args>
void pr(const Arg& first, const Args&... rest) {
  pr(first);
  pr(rest...);
}
template <class T1, class T2>
void pr(const pair<T1, T2>& x) {
  pr("{", x.first, ", ", x.second, "}");
}
template <class T, bool pretty = true>
void prContain(const T& x) {
  if (pretty) pr("{");
  bool fst = 1;
  for (const auto& a : x) pr(!fst ? pretty ? ", " : " " : "", a), fst = 0;
  if (pretty) pr("}");
}
template <class T>
void pc(const T& x) {
  prContain<T, false>(x);
  pr("\n");
}
template <class T, size_t SZ>
void pr(const array<T, SZ>& x) {
  prContain(x);
}
template <class T>
void pr(const vector<T>& x) {
  prContain(x);
}
template <class T>
void pr(const set<T>& x) {
  prContain(x);
}
template <class T1, class T2>
void pr(const map<T1, T2>& x) {
  prContain(x);
}
void ps() { pr("\n"); }
template <class Arg>
void ps(const Arg& first) {
  pr(first);
  ps();
}
template <class Arg, class... Args>
void ps(const Arg& first, const Args&... rest) {
  pr(first, " ");
  ps(rest...);
}
}  // namespace __output
using namespace __output;
namespace __algorithm {
template <typename T>
void dedup(vector<T>& v) {
  sort((v).begin(), (v).end());
  v.erase(unique((v).begin(), (v).end()), v.end());
}
template <typename T>
typename vector<T>::const_iterator find(const vector<T>& v, const T& x) {
  auto it = lower_bound((v).begin(), (v).end(), x);
  return it != v.end() && *it == x ? it : v.end();
}
template <typename T>
size_t index(const vector<T>& v, const T& x) {
  auto it = find(v, x);
  assert(it != v.end() && *it == x);
  return it - v.begin();
}
template <typename T1, typename T2>
typename vector<pair<T1, T2>>::iterator lower_bound(
    const vector<pair<T1, T2>>& v, const T1& x) {
  return lower_bound(
      (v).begin(), (v).end(), x,
      [](pair<T1, T2> a, pair<T1, T2> b) { return a.first < b.first; });
}
template <typename T1, typename T2>
typename vector<pair<T1, T2>>::iterator upper_bound(
    const vector<pair<T1, T2>>& v, const T1& x) {
  return upper_bound(
      (v).begin(), (v).end(), x,
      [](pair<T1, T2> a, pair<T1, T2> b) { return a.first < b.first; });
}
}  // namespace __algorithm
using namespace __algorithm;
struct __monostate {
  friend istream& operator>>(istream& is,
                             const __attribute__((unused)) __monostate& ms) {
    return is;
  }
  friend ostream& operator<<(ostream& os,
                             const __attribute__((unused)) __monostate& ms) {
    return os;
  }
} ms;
namespace __io {
void setIn(string second) { freopen(second.c_str(), "r", stdin); }
void setOut(string second) { freopen(second.c_str(), "w", stdout); }
void setIO(string second = "") {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout << setprecision(15);
  if (int((second).size())) {
    setIn(second + ".in"), setOut(second + ".out");
  }
}
}  // namespace __io
using namespace __io;
struct union_find_bipartite {
  struct node {
    int parent;
    int size = 1, root_status = -1, same_as_root = 1;
    bool root_path_parity = 0, consistent = 1;
    node(int id) : parent(id) {}
    int choices() const { return !consistent ? 0 : root_status == -1 ? 2 : 1; }
    int minimum_size() const {
      if (root_status == 1)
        return same_as_root;
      else if (root_status == 0)
        return size - same_as_root;
      return min(same_as_root, size - same_as_root);
    }
  };
  vector<node> uf;
  int components, bipartite_components, rank, minimum_size;
  union_find_bipartite(int N = 0)
      : components(N), bipartite_components(N), rank(N), minimum_size(0) {
    for (int v = 0; v < N; v++) {
      uf.emplace_back(v);
    }
  }
  int rep(int u) {
    if (uf[u].parent == u) return u;
    int root = rep(uf[u].parent);
    uf[u].root_path_parity ^= uf[uf[u].parent].root_path_parity;
    return uf[u].parent = root;
  }
  void subtract_component(int u) {
    components--;
    if (uf[u].consistent) {
      bipartite_components--;
      rank -= uf[u].root_status == -1;
      minimum_size -= uf[u].minimum_size();
    }
  }
  void add_component(int u) {
    components++;
    if (uf[u].consistent) {
      bipartite_components++;
      rank += uf[u].root_status == -1;
      minimum_size += uf[u].minimum_size();
    }
  }
  bool set_status(int u, bool u_status) {
    int u_root = rep(u);
    subtract_component(u_root);
    const bool implied_root_status = u_status ^ uf[u].root_path_parity;
    if (uf[u_root].root_status == -1) {
      uf[u_root].root_status = implied_root_status;
    } else if (uf[u_root].root_status != implied_root_status) {
      uf[u_root].consistent = false;
    }
    add_component(u_root);
    return uf[u_root].consistent;
  }
  struct result {
    bool added_connectivity, is_consistent;
  };
  result unite(int u, int v, bool edge_parity) {
    int u_root = rep(u), v_root = rep(v);
    if (u_root == v_root) {
      subtract_component(u_root);
      if (edge_parity != (uf[u].root_path_parity ^ uf[v].root_path_parity)) {
        uf[u_root].consistent = false;
      }
      add_component(u_root);
      return {false, uf[u_root].consistent};
    }
    edge_parity ^= uf[u].root_path_parity ^ uf[v].root_path_parity;
    u = u_root;
    v = v_root;
    if (uf[u].size < uf[v].size) swap(u, v);
    subtract_component(u), subtract_component(v);
    uf[v].parent = u;
    uf[v].root_path_parity = edge_parity;
    uf[u].size += uf[v].size;
    uf[u].consistent &= uf[v].consistent;
    if (edge_parity)
      uf[u].same_as_root += uf[v].size - uf[v].same_as_root;
    else
      uf[u].same_as_root += uf[v].same_as_root;
    if (uf[v].root_status != -1) {
      bool implied_u_status = uf[v].root_status ^ edge_parity;
      uf[u].consistent &=
          (uf[u].root_status == -1 || uf[u].root_status == implied_u_status);
      uf[u].root_status = implied_u_status;
    }
    add_component(u);
    return {true, uf[u].consistent};
  }
  result constrain_to_be_same(int u, int v) { return unite(u, v, 0); }
  result constrain_to_be_different(int u, int v) { return unite(u, v, 1); }
  bool is_consistent(int u, bool u_status) {
    int u_root = rep(u);
    if (!uf[u_root].consistent) return false;
    if (uf[u_root].root_status == -1) return true;
    return u_status == (uf[u].root_path_parity ^ uf[u_root].root_status);
  }
  bool is_consistent(int u, int v, bool edge_parity) {
    int u_root = rep(u), v_root = rep(v);
    if (!uf[u_root].consistent || !uf[v_root].consistent) {
      return false;
    } else if (u_root == v_root) {
      return edge_parity == (uf[u].root_path_parity ^ uf[v].root_path_parity);
    } else if (uf[u_root].root_status == -1 || uf[v_root].root_status == -1) {
      return true;
    } else {
      return (uf[u].root_path_parity ^ uf[u_root].root_status ^
              uf[v].root_path_parity ^ uf[v_root].root_status) == edge_parity;
    }
  }
};
int main() {
  setIO();
  int N, M;
  re(N, M);
  int n1, n2, n3;
  re(n1, n2, n3);
  array<int, 4> exp = {0, n1, n2, n3};
  union_find_bipartite ufb(N);
  vpii edges;
  bool ok = 1;
  for (int i = 0; i < (M); i++) {
    int u, v;
    re(u, v);
    --u, --v;
    edges.emplace_back(u, v);
    ok &= ufb.constrain_to_be_different(u, v).is_consistent;
  }
  if (!ok) {
    ps("NO");
    return 0;
  }
  vector<array<vi, 2>> comps(N);
  {
    for (int i = 0; i < (N); i++) {
      int p = ufb.rep(i);
      comps[p][ufb.uf[i].root_path_parity].push_back(i);
    }
    decltype(comps) tmp;
    for (auto& e : comps) {
      if (!e[0].empty() || !e[1].empty()) tmp.push_back(e);
    }
    comps = tmp;
  }
  int C = int((comps).size());
  vvi dp(C + 1, vi(N + 1, -1));
  dp[0][0] = 0;
  for (int i = 0; i < (C); i++) {
    for (int ct2 = 0; ct2 < (N + 1); ct2++)
      if (dp[i][ct2] != -1) {
        dp[i + 1][ct2 + int((comps[i][0]).size())] = 0;
        dp[i + 1][ct2 + int((comps[i][1]).size())] = 1;
      }
  }
  if (dp[C][n2] == -1) {
    ps("NO");
    return 0;
  }
  ps("YES");
  vi assign(N);
  int tmp = n2;
  for (int i = (C + 1) - 1; i >= (1); i--) {
    int inx = dp[i][tmp];
    for (auto& e : comps[i - 1][inx]) {
      assign[e] = 2;
      tmp--;
    }
  }
  for (auto& e : assign) {
    if (e == 2) continue;
    if (n1 > 0) {
      e = 1;
      n1--;
    } else {
      e = 3;
      n3--;
    }
  }
  array<int, 4> ct = {0, 0, 0, 0};
  for (auto& e : assign) ct[e]++;
  assert(ct == exp);
  for (auto& p : edges) {
    assert(abs(assign[p.first] - assign[p.second]) == 1);
  }
  for (auto& e : assign) pr(e);
  ps();
  return 0;
}

```