Phoenix is trying to take a photo of his n friends with labels 1, 2, ..., n who are lined up in a row in a special order. But before he can take the photo, his friends get distracted by a duck and mess up their order.

Now, Phoenix must restore the order but he doesn't remember completely! He only remembers that the i-th friend from the left had a label between a_i and b_i inclusive. Does there exist a unique way to order his friends based of his memory? 

Input

The first line contains one integer n (1 ≤ n ≤ 2⋅10^5) — the number of friends.

The i-th of the next n lines contain two integers a_i and b_i (1 ≤ a_i ≤ b_i ≤ n) — Phoenix's memory of the i-th position from the left.

It is guaranteed that Phoenix's memory is valid so there is at least one valid ordering.

Output

If Phoenix can reorder his friends in a unique order, print YES followed by n integers — the i-th integer should be the label of the i-th friend from the left.

Otherwise, print NO. Then, print any two distinct valid orderings on the following two lines. If are multiple solutions, print any.

Examples

Input


4
4 4
1 3
2 4
3 4


Output


YES
4 1 2 3 


Input


4
1 3
2 4
3 4
2 3


Output


NO
1 3 4 2 
1 2 4 3 


/**
 * @author egaeus
 * @mail sebegaeusprogram@gmail.com
 * @veredict
 * @url https://codeforces.com/problemset/problem/1348/F
 * @category adhoc
 * @date 01/05/2020
 **/

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.lang.reflect.Array;
import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

import static java.lang.Integer.parseInt;

public class CF1348F {
    public static void main(String args[]) throws Throwable {
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        for (String ln; (ln = in.readLine()) != null && !ln.equals(""); ) {
            int N = parseInt(ln);
            int[][] arr = new int[N][];
            for (int i = 0; i < N; i++) {
                StringTokenizer st = new StringTokenizer(in.readLine());
                arr[i] = new int[]{parseInt(st.nextToken()), parseInt(st.nextToken()), i, 0};
            }
            Arrays.sort(arr, (a, b) -> a[0] != b[0] ? a[0] - b[0] : a[1] - b[1]);
            int[] firstSolution = new int[N];
            int[] secondSolution = new int[N];
            MultiSet<Integer> multiSet = new MultiSet<>();
            for (int i = 0, j = 0; j < N; j++) {
                for(; i < arr.length && arr[i][0] <= j + 1; i++)
                    multiSet.add(arr[i][1], i);
                int position = multiSet.getFirst();
                secondSolution[arr[position][2]] = firstSolution[arr[position][2]] = j + 1;
                arr[position][3] = j + 1;
            }
            Arrays.sort(arr, Comparator.comparingInt(a -> a[3]));
            TreeSet<int[]> set = new TreeSet<>(Comparator.comparingInt(a -> a[0]));
            boolean ws = false;
            for (int i = 0; i < N; i++) {
                int[] get = set.ceiling(new int[]{i+1, i});
                if (get != null && arr[i][0] <= get[1] + 1 && i + 1 <= get[0]) {
                    int t = secondSolution[arr[i][2]];
                    secondSolution[arr[i][2]] = secondSolution[arr[get[1]][2]];
                    secondSolution[arr[get[1]][2]] = t;
                    ws = true;
                    break;
                }
                int[] add = new int[]{arr[i][1], i};
                if(set.contains(add))
                    set.remove(add);
                set.add(add);
            }
            System.out.println(!ws?"YES":"NO");
            System.out.println(IntStream.of(firstSolution).mapToObj(a -> a + "").collect(Collectors.joining(" ")));
            if(ws)
                System.out.println(IntStream.of(secondSolution).mapToObj(a -> a + "").collect(Collectors.joining(" ")));
        }
    }

    static class MultiSet<T extends Comparable> {
        private TreeMap<T, List<Integer>> map;

        public MultiSet() {
            map = new TreeMap<>();
        }

        public void add(T t, int index) {
            List<Integer> list = map.get(t);
            if(list == null)
                list = new LinkedList<>();
            list.add(index);
            map.put(t, list);
        }

        public int getFirst() {
            T key = map.firstKey();
            int index = map.get(key).remove(0);
            if(map.get(key).size() == 0)
                map.remove(key);
            return index;
        }
    }
}
