#define CPP17
#include <limits>
#include <initializer_list>
#include <utility>
#include <bitset>
#include <tuple>
#include <type_traits>
#include <functional>
#include <string>
#include <array>
#include <deque>
#include <list>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <iterator>
#include <algorithm>
#include <complex>
#include <random>
#include <numeric>
#include <iostream>
#include <iomanip>
#include <sstream>
#include <regex>
#include <cassert>
#include <cstddef>
#ifdef CPP17
#include <variant>
#endif

#define endl codeforces

#define ALL(v) std::begin(v), std::end(v)
#define ALLR(v) std::rbegin(v), std::rend(v)

using ll = std::int64_t;
using ull = std::uint64_t;
using pii = std::pair<int, int>;
using tii = std::tuple<int, int, int>;
using pll = std::pair<ll, ll>;
using tll = std::tuple<ll, ll, ll>;
using size_type = ssize_t;
template <typename T> using vec = std::vector<T>;
template <typename T> using vvec = vec<vec<T>>;

template <typename T> const T& var_min(const T &t) { return t; }
template <typename T> const T& var_max(const T &t) { return t; }
template <typename T, typename... Tail> const T& var_min(const T &t, const Tail&... tail) { return std::min(t, var_min(tail...)); }
template <typename T, typename... Tail> const T& var_max(const T &t, const Tail&... tail) { return std::max(t, var_max(tail...)); }
template <typename T, typename... Tail> void chmin(T &t, const Tail&... tail) { t = var_min(t, tail...); }
template <typename T, typename... Tail> void chmax(T &t, const Tail&... tail) { t = var_max(t, tail...); }

template <typename T, std::size_t Head, std::size_t... Tail> 
struct multi_dim_array { using type = std::array<typename multi_dim_array<T, Tail...>::type, Head>; };

template <typename T, std::size_t Head> 
struct multi_dim_array<T, Head> { using type = std::array<T, Head>; };

template <typename T, std::size_t... Args> using mdarray = typename multi_dim_array<T, Args...>::type;

#ifdef CPP17
template <typename T, typename F, typename... Args> 
void fill_seq(T &t, F f, Args... args) { 
    if constexpr (std::is_invocable<F, Args...>::value) { 
        t = f(args...); 
    } else { 
        for (size_type i = 0; i < t.size(); i++) fill_seq(t[i], f, args..., i); 
    } 
}
#endif

template <typename T> vec<T> make_v(size_type sz) { return vec<T>(sz); }

template <typename T, typename... Tail> 
auto make_v(size_type hs, Tail&&... ts) { 
    auto v = std::move(make_v<T>(std::forward<Tail>(ts)...)); 
    return vec<decltype(v)>(hs, v); 
}

namespace init__ { 
struct InitIO { 
    InitIO() { 
        std::cin.tie(nullptr); 
        std::ios_base::sync_with_stdio(false); 
        std::cout << std::fixed << std::setprecision(30); 
    } 
} init_io; 
}
template <typename T>
T ceil_pow2(T bound) {
    T ret = 1;
    while (ret < bound) ret *= 2;
    return ret;
}
template <typename T>
T ceil_div(T a, T b) { return a / b + !!(a % b); }
#define CPP17


vec<ll> solve() {
    ll n;
    std::cin >> n;
    vec<ll> av(n), bv(n);
    for (ll &e : av) std::cin >> e;
    for (ll &e : bv) std::cin >> e;

    std::map<ll, ll> cnt1, cnt2;
    for (ll e : av) cnt1[e]++;
    for (ll e : bv) cnt2[e]++;

    auto get_sum = [&](ll k) { return cnt1[k] + cnt2[k]; };

    vec<ll> keys;
    for (auto [ k, v ] : cnt1) keys.push_back(k);
    for (auto [ k, v ] : cnt2) keys.push_back(k);
    std::sort(ALL(keys));
    keys.erase(std::unique(ALL(keys)), keys.end());
    std::sort(ALLR(keys), [&](ll k1, ll k2) { return get_sum(k1) < get_sum(k2); });
    if (n < get_sum(keys.front())) return vec<ll>(0);

    vec<pll> nv;
    for (ll k : keys) {
        ll v1 = cnt1[k];
        while (v1--) nv.emplace_back(k, 0);
        ll v2 = cnt2[k];
        while (v2--) nv.emplace_back(k, 1);
    }


    auto fill = [&](ll sv) {
        vec<ll> ret(n, -1);
        ll idx = 0;
        for (ll i = 0; i < 2 * n; i++) {
            auto [ a, b ] = nv[i];
            if (b != sv) continue;
            if (i < n) {
                ret[i] = a;
                continue;
            }
            while (ret[idx] != -1) idx++;
            ret[idx++] = a;
        }
        return ret;
    };

    auto nav = fill(0);
    auto nbv = fill(1);

    std::map<ll, std::queue<ll>> fmp;
    for (ll i = 0; i < n; i++) fmp[nav[i]].push(nbv[i]);

    vec<ll> ret(n);
    for (ll i = 0; i < n; i++) {
        ll e = av[i];
        auto &q = fmp[e];
        ret[i] = q.front();
        q.pop();
    }

    for (ll i = 0; i < n; i++) if (av[i] == ret[i]) assert(false);

    return ret;
}

int main() {
    auto ans = solve();
    if (ans.empty()) {
        std::cout << "No\n";
    } else {
        std::cout << "Yes\n";
        for (ll i = 0; i < ans.size(); i++) std::cout << ans[i] << " \n"[i + 1 == ans.size()];
    }
    return 0;
}


Measured memory_bytes: 189076