Andrewid the Android is a galaxy-famous detective. He is now chasing a criminal hiding on the planet Oxa-5, the planet almost fully covered with water.

The only dry land there is an archipelago of *n* narrow islands located in a row. For more comfort let's represent them as non-intersecting segments on a straight line: island *i* has coordinates [*l*<sub class="lower-index">*i*</sub>, *r*<sub class="lower-index">*i*</sub>], besides, *r*<sub class="lower-index">*i*</sub> &lt; *l*<sub class="lower-index">*i* + 1</sub> for 1 ≤ *i* ≤ *n* - 1.

To reach the goal, Andrewid needs to place a bridge between each pair of adjacent islands. A bridge of length *a* can be placed between the *i*-th and the (*i* + 1)-th islads, if there are such coordinates of *x* and *y*, that *l*<sub class="lower-index">*i*</sub> ≤ *x* ≤ *r*<sub class="lower-index">*i*</sub>, *l*<sub class="lower-index">*i* + 1</sub> ≤ *y* ≤ *r*<sub class="lower-index">*i* + 1</sub> and *y* - *x* = *a*. 

The detective was supplied with *m* bridges, each bridge can be used at most once. Help him determine whether the bridges he got are enough to connect each pair of adjacent islands.
The first line contains integers *n* (2 ≤ *n* ≤ 2·10<sup class="upper-index">5</sup>) and *m* (1 ≤ *m* ≤ 2·10<sup class="upper-index">5</sup>) — the number of islands and bridges.

Next *n* lines each contain two integers *l*<sub class="lower-index">*i*</sub> and *r*<sub class="lower-index">*i*</sub> (1 ≤ *l*<sub class="lower-index">*i*</sub> ≤ *r*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">18</sup>) — the coordinates of the island endpoints.

The last line contains *m* integer numbers *a*<sub class="lower-index">1</sub>, *a*<sub class="lower-index">2</sub>, ..., *a*<sub class="lower-index">*m*</sub> (1 ≤ *a*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">18</sup>) — the lengths of the bridges that Andrewid got.
#!/usr/bin/env python
# 556D_fug.py - Codeforces.com 556D Fug quiz
#
# Copyright (C) 2015 Sergey
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#       http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

"""
Input

The first line contains integers n and m - the number of islands and bridges.

Next n lines each contain two integers li and ri - the coordinates of the
island endpoints.

The last line contains m integer numbers a1..am - the lengths of the bridges
that Andrewid got.
Output

If it is impossible to place a bridge between each pair of adjacent islands
in the required manner, print on a single line "No" (without the quotes)
, otherwise print in the first line "Yes" (without the quotes), and in the
second line print n-1 numbers b1, bn-1, which mean that between islands
i and i+1 there must be used a bridge number bi.

If there are multiple correct answers, print any of them. Note that in this
problem it is necessary to print "Yes" and "No" in correct case
"""

# Standard libraries
import unittest
import sys
import re

# Additional libraries
import bisect


###############################################################################
# Fug Class
###############################################################################


class Fug:
    """ Fug representation """

    def __init__(self, args):
        """ Default constructor """
        self.list = args[0]
        self.alist = args[1]
        self.gn = len(self.list) - 1

        # Sorted list of bridges
        self.asrt = sorted((n, i) for i, n in enumerate(self.alist))

        # List of gaps between islands
        self.gaps = []
        for i in range(self.gn):
            min = self.list[i+1][0] - self.list[i][1]
            max = self.list[i+1][1] - self.list[i][0]
            self.gaps.append((min, max, i))

        # Sorted list of gaps between islands
        self.gsrt = sorted(self.gaps)

        self.gmin = [n[0] for n in self.gsrt]
        self.gmax = [n[1] for n in self.gsrt]
        self.gi = [n[2] for n in self.gsrt]

        self.result = [None for i in range(self.gn)]

    def iterate(self):

        for (b, i) in self.asrt:
            self.ia = b

            # Bisect the gap array to find gaps matching current bridge
            self.igr = bisect.bisect_right(self.gmin, b)

            # Find minimum maximum gap size
            self.imin = sys.maxsize
            self.imini = None
            for j in range(0, self.igr):
                gmaxj = self.gmax[j]
                if gmaxj < self.imin:
                    self.imin = gmaxj
                    self.imini = j

            # Exit if min gap max smaller than the current bridge
            if self.imin < b or self.imini is None:
                break

            # Update result and remove the element from lists
            self.result[self.gi[self.imini]] = i
            self.gmin.pop(self.imini)
            self.gmax.pop(self.imini)
            self.gi.pop(self.imini)

            yield

    def calculate(self):
        """ Main calcualtion function of the class """

        for it in self.iterate():
            pass

        for n in self.result:
            if n is None:
                return "No"

        answer = " ".join([str(n + 1) for n in self.result])

        return "Yes\n" + answer


###############################################################################
# Executable code
###############################################################################


def get_inputs(test_inputs=None):

    it = iter(test_inputs.split("\n")) if test_inputs else None

    def uinput():
        """ Unit-testable input function wrapper """
        if it:
            return next(it)
        else:
            return input()

    # Getting string inputs. Place all uinput() calls here
    num = [int(s) for s in uinput().split()]
    list = [[int(s) for s in uinput().split()] for i in range(num[0])]
    alist = [int(s) for s in uinput().split()]

    # Decoding inputs into a list
    inputs = [list, alist]

    return inputs


def calculate(test_inputs=None):
    """ Base class calculate method wrapper """
    return Fug(get_inputs(test_inputs)).calculate()


###############################################################################
# Unit Tests
###############################################################################


class unitTests(unittest.TestCase):

    def test_sample_tests(self):
        """ Quiz sample tests. Add \n to separate lines """

        # Sample test 1
        test = "4 4\n1 4\n7 8\n9 10\n12 14\n4 5 3 8"
        self.assertEqual(calculate(test), "Yes\n2 3 1")
        self.assertEqual(
            get_inputs(test),
            [[[1, 4], [7, 8], [9, 10], [12, 14]], [4, 5, 3, 8]])

        # Other tests
        test = "2 2\n11 14\n17 18\n2 9"
        self.assertEqual(calculate(test), "No")

        test = ("2 1\n1 1\n1000000000000000000 1000000000000000000" +
                "\n999999999999999999")
        self.assertEqual(calculate(test), "Yes\n1")

        test = ("5 9\n1 2\n3 3\n5 7\n11 13\n14 20\n2 3 4 10 6 2 6 9 5")
        self.assertEqual(calculate(test), "Yes\n1 6 3 2")

        size = 1000
        test = str(size) + " " + str(size) + "\n"
        x = size*1000
        for i in range(size):
            x += 2
            test += str(x) + " " + str(x+1) + "\n"
        for i in range(size):
            test += str(2) + " "
        self.assertEqual(calculate(test)[0], "Y")

    def test_Fug_class__basic_functions(self):
        """ Fug class basic functions testing """

        # Constructor test
        d = Fug([[[1, 5], [7, 8], [9, 10], [12, 14]], [4, 5, 3, 8]])
        self.assertEqual(d.list[0][0], 1)
        self.assertEqual(d.alist[0], 4)

        # Sort bridges
        self.assertEqual(d.asrt[0], (3, 2))

        # Sort Gaps
        self.assertEqual(d.gaps[0], (2, 7, 0))
        self.assertEqual(d.gsrt[0], (1, 3, 1))

        iter = d.iterate()
        next(iter)
        self.assertEqual(d.ia, 3)
        self.assertEqual(d.igr, 3)
        self.assertEqual(d.imin, 3)
        self.assertEqual(d.imini, 0)
        self.assertEqual(d.gmin, [2, 2])
        self.assertEqual(d.gmax, [5, 7])

if __name__ == "__main__":

    # Avoiding recursion limitaions
    sys.setrecursionlimit(100000)

    if sys.argv[-1] == "-ut":
        unittest.main(argv=[" "])

    # Print the result string
    print(calculate())
