#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000000 + 7;
const long long LL_INF = 1ll * INF * INF;
const int MAX_N = 500000 + 7;
template <typename T>
inline void addmod(T& a, const long long& b, const int& MOD = INF) {
  a = (a + b) % MOD;
  if (a < 0) a += MOD;
}
int cnt[MAX_N];
vector<int> a;
int nxt_ptr[MAX_N * 2];
int prev_ptr[MAX_N * 2];
int n;
vector<int> un_used;
int first_index[MAX_N], last_index[MAX_N];
void update(int pos, int value) {
  a[pos] = value;
  first_index[value] = min(first_index[value], pos);
  last_index[value] = max(last_index[value], pos);
}
bool inside(int value, int lhs, int rhs) {
  return first_index[value] >= lhs && last_index[value] <= rhs;
}
bool fill_range(int u, int v) {
  int last = -1;
  for (int i = nxt_ptr[u]; i < v; i = nxt_ptr[i])
    if (!a[i]) {
      if (last == -1) {
        if (un_used.empty()) {
          return false;
        }
        last = un_used.back();
        un_used.pop_back();
      }
      update(i, last);
    }
  return true;
}
void merge_node(int u, int v) {
  if (prev_ptr[u] != -1) {
    nxt_ptr[prev_ptr[u]] = v;
  }
  prev_ptr[v] = prev_ptr[u];
}
bool recover(int u, int v) {
  if ((v - u) & 1) return false;
  for (int i = nxt_ptr[u]; i < v; i = nxt_ptr[i])
    if (a[i] != 0 && !inside(a[i], u, v)) return false;
  vector<pair<bool, int>> stack_;
  for (int i = u; i <= v; i = nxt_ptr[i]) {
    stack_.push_back({a[i] > 0, i});
    while (stack_.size() >= 3) {
      int sz = (int)(stack_).size();
      if ((stack_[sz - 1].first ^ stack_[sz - 3].first) &&
          stack_[sz - 2].first) {
        int arr_[3];
        for (int j = (0), _b = (3); j < _b; ++j) {
          arr_[j] = stack_.back().second;
          stack_.pop_back();
        }
        int mx = max(a[arr_[0]], a[arr_[2]]);
        a[arr_[0]] = a[arr_[2]] = mx;
        merge_node(arr_[2], arr_[0]);
        stack_.push_back({true, arr_[0]});
      } else
        break;
    }
  }
  while (stack_.size() >= 3) {
    int sz = (int)(stack_).size();
    if (stack_[sz - 1].first && stack_[sz - 2].first && stack_[sz - 3].first) {
      if (a[stack_[sz - 1].second] != a[u]) return false;
    }
    stack_.pop_back();
  }
  int last = u;
  for (int i = u, j = 0; i <= v; i = nxt_ptr[i], ++j)
    if ((i - last) % 2 == 0) {
      if (i != last && (a[i] == a[u] || a[i] == 0)) {
        update(i, a[u]);
        bool check = fill_range(last, i);
        if (!check) return false;
        last = i;
      }
    }
  merge_node(u, v);
  return true;
}
int last_position[MAX_N];
void solve() {
  cin >> n;
  int m_len = 2 * n - 1;
  a.resize(m_len);
  for (int i = 1; i <= n; ++i) {
    first_index[i] = m_len + 1;
    last_index[i] = -1;
    last_position[i] = -1;
  }
  for (int i = (0), _b = (m_len); i < _b; ++i) {
    nxt_ptr[i] = i + 1;
    prev_ptr[i] = i - 1;
    int u = 0;
    cin >> u;
    if (u) cnt[u]++;
    update(i, u);
  }
  for (int i = 1; i <= n; ++i)
    if (cnt[i] == 0) {
      un_used.push_back(i);
    }
  bool check = true;
  if (a[0] == 0 || a[m_len - 1] == 0) {
    if (a[0] == 0 && a[m_len - 1] == 0) {
      check = !un_used.empty();
      if (check) {
        a[m_len - 1] = a[0] = un_used.back();
        un_used.pop_back();
      }
    } else {
      int mx = max(a[0], a[m_len - 1]);
      update(0, mx);
      update(m_len - 1, mx);
    }
  } else {
    check &= a[0] == a[m_len - 1];
  }
  for (int i = 0; i < m_len && check; ++i) {
    int u = a[i];
    if (!u) continue;
    if (last_position[u] != -1) {
      int prev_i = last_position[u];
      check &= recover(prev_i, i);
    }
    last_position[u] = i;
  }
  if (check) {
    cout << "yes\n";
    for (int i = 0; i < m_len; ++i) {
      cout << a[i] << " \n"[i + 1 == m_len];
    }
  } else {
    cout << "no\n";
  }
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  const bool multiple_test = false;
  int test = 1;
  if (multiple_test) cin >> test;
  for (int i = 0; i < test; ++i) {
    solve();
  }
}
