#include <bits/stdc++.h>
using namespace std;
template <typename... As>
struct tpl : public std::tuple<As...> {
  using std::tuple<As...>::tuple;
  tpl() {}
  tpl(std::tuple<As...> const& b) { std::tuple<As...>::operator=(b); }
  template <typename T = tuple<As...> >
  typename tuple_element<0, T>::type const& x() const {
    return get<0>(*this);
  }
  template <typename T = tuple<As...> >
  typename tuple_element<0, T>::type& x() {
    return get<0>(*this);
  }
  template <typename T = tuple<As...> >
  typename tuple_element<1, T>::type const& y() const {
    return get<1>(*this);
  }
  template <typename T = tuple<As...> >
  typename tuple_element<1, T>::type& y() {
    return get<1>(*this);
  }
  template <typename T = tuple<As...> >
  typename tuple_element<2, T>::type const& z() const {
    return get<2>(*this);
  }
  template <typename T = tuple<As...> >
  typename tuple_element<2, T>::type& z() {
    return get<2>(*this);
  }
  template <typename T = tuple<As...> >
  typename tuple_element<3, T>::type const& w() const {
    return get<3>(*this);
  }
  template <typename T = tuple<As...> >
  typename tuple_element<3, T>::type& w() {
    return get<3>(*this);
  }
};
using lli = long long int;
using llu = long long unsigned;
using pii = tpl<lli, lli>;
using piii = tpl<lli, lli, lli>;
using piiii = tpl<lli, lli, lli, lli>;
using vi = vector<lli>;
using vii = vector<pii>;
using viii = vector<piii>;
using vvi = vector<vi>;
using vvii = vector<vii>;
using vviii = vector<viii>;
template <class T>
using min_queue = priority_queue<T, vector<T>, greater<T> >;
template <class T>
using max_queue = priority_queue<T>;
template <size_t... I>
struct my_index_sequence {
  using type = my_index_sequence;
  static constexpr array<size_t, sizeof...(I)> value = {{I...}};
};
namespace my_index_sequence_detail {
template <typename I, typename J>
struct concat;
template <size_t... I, size_t... J>
struct concat<my_index_sequence<I...>, my_index_sequence<J...> >
    : my_index_sequence<I..., (sizeof...(I) + J)...> {};
template <size_t N>
struct make_index_sequence
    : concat<typename make_index_sequence<N / 2>::type,
             typename make_index_sequence<N - N / 2>::type>::type {};
template <>
struct make_index_sequence<0> : my_index_sequence<> {};
template <>
struct make_index_sequence<1> : my_index_sequence<0> {};
}  // namespace my_index_sequence_detail
template <class... A>
using my_index_sequence_for =
    typename my_index_sequence_detail::make_index_sequence<sizeof...(A)>::type;
template <class T, size_t... I>
void print_tuple(ostream& s, T const& a, my_index_sequence<I...>) {
  using swallow = int[];
  (void)swallow{0, (void(s << (I == 0 ? "" : ", ") << get<I>(a)), 0)...};
}
template <class T>
ostream& print_collection(ostream& s, T const& a);
template <class... A>
ostream& operator<<(ostream& s, tpl<A...> const& a);
template <class... A>
ostream& operator<<(ostream& s, tuple<A...> const& a);
template <class A, class B>
ostream& operator<<(ostream& s, pair<A, B> const& a);
template <class T, size_t I>
ostream& operator<<(ostream& s, array<T, I> const& a) {
  return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, vector<T> const& a) {
  return print_collection(s, a);
}
template <class T, class U>
ostream& operator<<(ostream& s, multimap<T, U> const& a) {
  return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, multiset<T> const& a) {
  return print_collection(s, a);
}
template <class T, class U>
ostream& operator<<(ostream& s, map<T, U> const& a) {
  return print_collection(s, a);
}
template <class T>
ostream& operator<<(ostream& s, set<T> const& a) {
  return print_collection(s, a);
}
template <class T>
ostream& print_collection(ostream& s, T const& a) {
  s << '[';
  for (auto it = begin(a); it != end(a); ++it) {
    s << *it;
    if (it != prev(end(a))) s << " ";
  }
  return s << ']';
}
template <class... A>
ostream& operator<<(ostream& s, tpl<A...> const& a) {
  s << '(';
  print_tuple(s, a, my_index_sequence_for<A...>{});
  return s << ')';
}
template <class... A>
ostream& operator<<(ostream& s, tuple<A...> const& a) {
  s << '(';
  print_tuple(s, a, my_index_sequence_for<A...>{});
  return s << ')';
}
template <class A, class B>
ostream& operator<<(ostream& s, pair<A, B> const& a) {
  return s << "(" << get<0>(a) << ", " << get<1>(a) << ")";
}
int C[200000];
void fail() {
  cout << "No" << endl;
  exit(0);
}
void output(int n) {
  cout << "Yes" << endl;
  for (lli i = 0; i < (lli)(2 * n); ++i) cout << C[i] << ' ';
  cout << endl;
  exit(0);
}
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  int n;
  cin >> n;
  string s;
  cin >> s;
  s = '1' + s + '1';
  vi ins, outs;
  vi gates, other;
  for (lli i = 0; i < (lli)(2 * n); ++i) {
    if (s[i] == '0') {
      if (s[i + 1] == '0') {
        other.push_back(i);
      } else {
        outs.push_back(i);
      }
    } else {
      if (s[i + 1] == '0') {
        ins.push_back(i);
      } else {
        gates.push_back(i);
      }
    }
  }
  for (lli i = 0; i < (lli)(2 * n); ++i) C[i] = -1;
  if (ins.size() != outs.size() || (gates.size() & 1) || (other.size() & 1))
    fail();
  int nc = 1;
  for (lli j = 0; j < (lli)(other.size() / 2); ++j) {
    C[other[2 * j]] = C[other[2 * j + 1]] = nc++;
  }
  if (gates.size() % 4 == 0) {
    for (lli i = 0; i < (lli)(ins.size()); ++i) C[ins[i]] = C[outs[i]] = nc++;
    for (lli i = 0; i < (lli)(gates.size() / 4); ++i) {
      C[gates[4 * i]] = C[gates[4 * i + 2]] = nc++;
      C[gates[4 * i + 1]] = C[gates[4 * i + 3]] = nc++;
    }
    output(n);
    return 0;
  }
  int i0 = -1;
  int k0 = -1;
  for (lli i = 0; i < (lli)(2 * n); ++i) {
    if (s[i] == '1' && s[i + 1] == '1' && i0 != -1) {
      k0 = i;
      break;
    }
    if (s[i] == '0' && s[i + 1] == '1') {
      i0 = i;
    }
  }
  if (i0 == -1 || k0 == -1) fail();
  int j0 = k0;
  while (1) {
    if (j0 == 2 * n) fail();
    if (s[j0] == '1' && s[j0 + 1] == '0') break;
    j0++;
  }
  C[i0] = C[j0] = nc++;
  int k1 = -1;
  for (int k : gates)
    if (k < i0 || k > j0) {
      k1 = k;
      break;
    }
  if (k1 == -1) fail();
  C[k0] = C[k1] = nc++;
  vi gates2, ins2, outs2;
  {
    int i = 0;
    while (i < 2 * n) {
      if (s[i] == '0' && s[i + 1] == '1')
        ins2.push_back(i);
      else if (s[i] == '1' && s[i + 1] == '0')
        outs2.push_back(i);
      else if (s[i] == '1' && s[i + 1] == '1')
        gates2.push_back(i);
      i += 1;
      if (i == k0)
        i = k1;
      else if (i == k1)
        i = k0;
      else if (i == i0)
        i = j0;
      else if (i == j0)
        i = i0;
    }
  }
  for (lli i = 0; i < (lli)(ins2.size()); ++i) C[ins2[i]] = C[outs2[i]] = nc++;
  for (lli i = 0; i < (lli)(gates2.size() / 4); ++i) {
    C[gates2[4 * i]] = C[gates2[4 * i + 2]] = nc++;
    C[gates2[4 * i + 1]] = C[gates2[4 * i + 3]] = nc++;
  }
  output(n);
  return 0;
}
