#include<iostream>
#include<vector>
#include<queue>
#include<algorithm>
#include<cassert>

#include <algorithm>
#include <cassert>
#include <vector>


#ifdef _MSC_VER
#include <intrin.h>
#endif

namespace atcoder {

namespace internal {

int ceil_pow2(int n) {
    int x = 0;
    while ((1U << x) < (unsigned int)(n)) x++;
    return x;
}

constexpr int bsf_constexpr(unsigned int n) {
    int x = 0;
    while (!(n & (1 << x))) x++;
    return x;
}

int bsf(unsigned int n) {
#ifdef _MSC_VER
    unsigned long index;
    _BitScanForward(&index, n);
    return index;
#else
    return __builtin_ctz(n);
#endif
}

}  // namespace internal

}  // namespace atcoder


namespace atcoder {

template <class S, S (*op)(S, S), S (*e)()> struct segtree {
  public:
    segtree() : segtree(0) {}
    explicit segtree(int n) : segtree(std::vector<S>(n, e())) {}
    explicit segtree(const std::vector<S>& v) : _n(int(v.size())) {
        log = internal::ceil_pow2(_n);
        size = 1 << log;
        d = std::vector<S>(2 * size, e());
        for (int i = 0; i < _n; i++) d[size + i] = v[i];
        for (int i = size - 1; i >= 1; i--) {
            update(i);
        }
    }

    void set(int p, S x) {
        assert(0 <= p && p < _n);
        p += size;
        d[p] = x;
        for (int i = 1; i <= log; i++) update(p >> i);
    }

    S get(int p) const {
        assert(0 <= p && p < _n);
        return d[p + size];
    }

    S prod(int l, int r) const {
        assert(0 <= l && l <= r && r <= _n);
        S sml = e(), smr = e();
        l += size;
        r += size;

        while (l < r) {
            if (l & 1) sml = op(sml, d[l++]);
            if (r & 1) smr = op(d[--r], smr);
            l >>= 1;
            r >>= 1;
        }
        return op(sml, smr);
    }

    S all_prod() const { return d[1]; }

    template <bool (*f)(S)> int max_right(int l) const {
        return max_right(l, [](S x) { return f(x); });
    }
    template <class F> int max_right(int l, F f) const {
        assert(0 <= l && l <= _n);
        assert(f(e()));
        if (l == _n) return _n;
        l += size;
        S sm = e();
        do {
            while (l % 2 == 0) l >>= 1;
            if (!f(op(sm, d[l]))) {
                while (l < size) {
                    l = (2 * l);
                    if (f(op(sm, d[l]))) {
                        sm = op(sm, d[l]);
                        l++;
                    }
                }
                return l - size;
            }
            sm = op(sm, d[l]);
            l++;
        } while ((l & -l) != l);
        return _n;
    }

    template <bool (*f)(S)> int min_left(int r) const {
        return min_left(r, [](S x) { return f(x); });
    }
    template <class F> int min_left(int r, F f) const {
        assert(0 <= r && r <= _n);
        assert(f(e()));
        if (r == 0) return 0;
        r += size;
        S sm = e();
        do {
            r--;
            while (r > 1 && (r % 2)) r >>= 1;
            if (!f(op(d[r], sm))) {
                while (r < size) {
                    r = (2 * r + 1);
                    if (f(op(d[r], sm))) {
                        sm = op(d[r], sm);
                        r--;
                    }
                }
                return r + 1 - size;
            }
            sm = op(d[r], sm);
        } while ((r & -r) != r);
        return 0;
    }

  private:
    int _n, size, log;
    std::vector<S> d;

    void update(int k) { d[k] = op(d[2 * k], d[2 * k + 1]); }
};

}  // namespace atcoder

using namespace std;
struct dat{
	int maxv,minv,maxa,maxb;
	bool emp;
};
dat op(dat l,dat r)
{
	if(l.emp)return r;
	if(r.emp)return l;
	l.maxv=max(l.maxv,r.maxv);
	l.minv=min(l.minv,r.minv);
	l.maxa=max(l.maxa,r.maxa);
	l.maxb=max(l.maxb,r.maxb);
	return l;
}
dat e(){return(dat){0,0,0,0,true};}
int N;
int A[1<<17],B[1<<17];
int invA[1<<17],invB[1<<17];
vector<int>G[1<<17];
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(nullptr);
	cin>>N;
	for(int i=0;i<N;i++)
	{
		cin>>A[i];
		invA[A[i]]=i;
	}
	for(int i=0;i<N;i++)
	{
		cin>>B[i];
		invB[B[i]]=i;
	}
	atcoder::segtree<dat,op,e>seg(N);
	for(int i=0;i<N;i++)
	{
		int r=invB[A[i]];
		dat t=seg.prod(0,r);
		if(!t.emp)
		{
			vector<int>U;
			U.push_back(t.maxv);
			U.push_back(t.minv);
			U.push_back(A[t.maxa]);
			U.push_back(B[t.maxb]);
			sort(U.begin(),U.end());
			U.erase(unique(U.begin(),U.end()),U.end());
			for(int u:U)
			{
				G[u].push_back(A[i]);
			}
		}
		t.emp=false;
		t.maxv=t.minv=A[i];
		t.maxa=i;
		t.maxb=r;
		seg.set(r,t);
	}
	priority_queue<int>BQ;
	priority_queue<int,vector<int>,greater<int> >AQ;
	vector<int>An,Bn;
	vector<int>degA(N+1),degB(N+1);
	for(int i=1;i<=N;i++)for(int v:G[i])
	{
		degA[v]++;
		degB[v]++;
	}
	for(int i=1;i<=N;i++)if(!degA[i])
	{
		AQ.push(i);
		BQ.push(i);
	}
	while(!AQ.empty())
	{
		int u=AQ.top();
		AQ.pop();
		An.push_back(u);
		for(int v:G[u])if(!--degA[v])AQ.push(v);
	}
	while(!BQ.empty())
	{
		int u=BQ.top();
		BQ.pop();
		Bn.push_back(u);
		for(int v:G[u])if(!--degB[v])BQ.push(v);
	}
	if(An!=vector<int>(A,A+N)||Bn!=vector<int>(B,B+N))cout<<"No\n";
	else
	{
		cout<<"Yes\n";
		int M=0;
		for(int i=1;i<=N;i++)for(int v:G[i])M++;
		cout<<M<<"\n";
		for(int i=1;i<=N;i++)for(int v:G[i])cout<<i<<" "<<v<<"\n";
	}
}