// ---------- begin persistent stack ----------
#[allow(dead_code)]
mod persistent_stack {
    use std::rc::Rc;

    type Ref<T> = Rc<Node<T>>;
    type Link<T> = Option<Ref<T>>;

    struct Node<T> {
        value: T,
        next: Link<T>,
    }

    impl<T> Node<T> {
        fn new(value: T, next: Link<T>) -> Self {
            Node { value, next }
        }
    }

    #[derive(Clone)]
    pub struct Stack<T> {
        size: usize,
        node: Link<T>,
    }

    impl<T> Drop for Stack<T> {
        fn drop(&mut self) {
            let mut root = self.node.take();
            while let Some(Some(node)) = root.as_mut().map(|p| Rc::get_mut(p)) {
                root = node.next.take();
            }
        }
    }

    impl<T> Stack<T> {
        fn build(size: usize, node: Link<T>) -> Self {
            Stack { size, node }
        }
        pub fn new() -> Self {
            Stack::build(0, None)
        }
        #[must_use]
        pub fn push(&self, value: T) -> Self {
            let node = Some(Rc::new(Node::new(value, self.node.clone())));
            Stack::build(self.size + 1, node)
        }
        pub fn top(&self) -> Option<&T> {
            self.node.as_ref().map(|p| &p.value)
        }
        #[must_use]
        pub fn pop(&self) -> Option<(Self, &T)> {
            self.node.as_ref().map(|p| {
                let s = Stack::build(self.size - 1, p.next.clone());
                (s, &p.value)
            })
        }
        pub fn len(&self) -> usize {
            self.size
        }
        pub fn is_empty(&self) -> bool {
            self.size == 0
        }
    }

    pub struct Iter<'a, T> {
        next: Option<&'a Ref<T>>,
    }

    impl<T> Stack<T> {
        pub fn iter(&self) -> Iter<T> {
            Iter {
                next: self.node.as_ref(),
            }
        }
    }

    impl<'a, T> Iterator for Iter<'a, T> {
        type Item = &'a T;
        fn next(&mut self) -> Option<Self::Item> {
            self.next.take().map(|p| {
                self.next = p.next.as_ref();
                &p.value
            })
        }
    }
}
// ---------- end persistent stack ----------
// ---------- begin input macro ----------
// reference: https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};
    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };
    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };
    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };
    ($iter:expr, bytes) => {
        read_value!($iter, String).bytes().collect::<Vec<u8>>()
    };
    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };
    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}
// ---------- end input macro ----------

use std::io::Write;

fn run() {
    input! {
        n: usize,
        q: usize,
        a: [usize; q],
        b: [usize; q],
    }
    type Stack = persistent_stack::Stack<(usize, usize)>;
    let mut dp = vec![Stack::new(); n + 2];
    for i in 1..=n {
        dp[i] = dp[i].push((i, 0));
    }
    let mut range = vec![(1, n + 1)];
    for (i, (&a, &b)) in a.iter().zip(b.iter()).enumerate() {
        let t = i + 1;
        for p in range.iter_mut() {
            if p.0 > 1 && dp[p.0 - 1].is_empty() {
                dp[p.0 - 1] = dp[p.0].push((p.0 - 1, t));
                p.0 -= 1;
            }
            if p.1 <= n && dp[p.1].is_empty() {
                dp[p.1] = dp[p.1 - 1].push((p.1, t));
                p.1 += 1;
            }
        }
        range.dedup_by(|a, b| {
            b.1 == a.0 && {
                b.1 = a.1;
                true
            }
        });
        dp[a] = Stack::new();
        dp[b] = Stack::new();
        for &p in [a, b].iter() {
            let mut next = vec![];
            for (l, r) in range {
                if l <= p && p < r {
                    if l < p {
                        next.push((l, p));
                    }
                    if p + 1 < r {
                        next.push((p + 1, r));
                    }
                } else {
                    next.push((l, r));
                }
            }
            range = next;
        }
    }
    if let Some(x) = dp.iter().find(|s| !s.is_empty()) {
        println!("YES");
        let mut pos = vec![0; q + 1];
        for &(a, b) in x.iter() {
            pos[b] = a;
        }
        for i in 1..=q {
            if pos[i] == 0 {
                pos[i] = pos[i - 1];
            }
        }
        let out = std::io::stdout();
        let mut out = std::io::BufWriter::new(out.lock());
        for p in pos.iter() {
            writeln!(out, "{}", *p).ok();
        }
    } else {
        println!("NO");
    }
}

fn main() {
    run();
}