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.
import heapq

def read_data():
    n, m = map(int, input().split())
    LR = []
    for i in range(n):
        l, r = map(int, input().split())
        LR.append((l, r))
    As = list(map(int, input().split()))
    return n, m, LR, As

def solve(n, m, LR, As):
    if m < n - 1:
        return False
    mins, maxs = convert2minmax(LR)
    mins.sort()
    As = [(a, i) for i, a in enumerate(As, 1)]
    As.sort()
    allocation = [0] * (n - 1)
    gaps = []
    allocated = 0
    mins_cursor = 0
    for a, bridge_id in As:
        mins_cursor = update_gaps(gaps, a, mins, maxs, mins_cursor)
        if gaps:
            maxgap, gap_id = heapq.heappop(gaps)
            if maxgap < a:
                return False
            allocation[gap_id] = bridge_id
            allocated += 1
    if allocated != n - 1:
        return False
    return allocation


def convert2minmax(LR):
    prevL, prevR = LR[0]
    mins = []
    maxs = []
    for i, (L, R) in enumerate(LR[1:]):
        mins.append((L - prevR, i))
        maxs.append(R - prevL)
        prevL, prevR = L, R
    return mins, maxs

def update_gaps(gaps, a, mins, maxs, mins_cursor):
    cursor = mins_cursor
    for mingap, gap_id in mins[mins_cursor:]:
        if mingap <= a:
            heapq.heappush(gaps, (maxs[gap_id], gap_id))
            cursor += 1
        else:
            break
    return cursor

if __name__ == '__main__':
    n, m, LR, As = read_data()
    result = solve(n, m, LR, As)
    if result:
        print('Yes')
        print(*result)
    else:
        print('No')