RT.
AC 70 WA 15
前 310 行是模板
atcoder 的题解区挂了一个推特的链接，但是没有魔法进不去，把里面的 hack 数据发出来也行。

/bx

#include <bits/stdc++.h>
#include <ext/rope>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#include <ext/pb_ds/priority_queue.hpp>
using namespace std;
#define FOR(i, a, b) for (int i = a; i <= b; i++)
#define REP(i, a, b) for (int i = a; i >= b; i--)
#define pb push_back
#define eb emplace_back
#define popcount __builtin_popcount
#define ctz __builtin_ctz
#define gc getchar()
#define mkpr make_pair
#define i128 __int128
typedef long long ll;
typedef unsigned long long ull;
typedef std::pair<int, int> pii;
typedef std::pair<ll, ll> pll;
template <class T>
void write(T x)
{
    if (x < 0)
    {
        putchar('-');
        x = -x;
    }
    if (x >= 10)
    {
        write(x / 10);
    }
    putchar(x % 10 ^ 48);
}
template <class T>
void read(T &x)
{
    x = 0;
    T f = 1;
    char ch = getchar();
    while (!isdigit(ch))
    {
        if (ch == '-')
            f = -1;
        ch = getchar();
    }
    while (isdigit(ch))
    {
        x = (x << 1) + (x << 3) + (ch ^ 48);
        ch = getchar();
    }
    x *= f;
}
template <class T>
T quick_pow(T a, T b, T p = -1)
{
    if (p == -1)
    {
        T res = 1;
        while (b)
        {
            if (b & 1)
                res = res * a;
            a *= a;
            b >>= 1;
        }
        return res;
    }
    else
    {
        T res = 1;
        while (b)
        {
            if (b & 1)
                res = res * a % p;
            a = a * a % p;
            b >>= 1;
        }
        return res;
    }
}
template <class T>
T inv(T x, T p) { return quick_pow(x, p - 2, p); }
ll qpow(ll a, ll b, ll mod)
{
    ll res = 1;
    while (b)
    {
        if (b & 1)
            res = res * a % mod;
        a = a * a % mod;
        b >>= 1;
    }
    return res;
}
ll invll(ll a, ll mod)
{
    return qpow(a, mod - 2, mod);
}
struct Matrix
{
    vector<vector<ll>> mp;
    ll p;
    int size;
    // 第二个参数：是否设为单位矩阵
    void init(int siz, ll mod = -1, bool isdw = 0)
    {
        p = mod;
        size = siz;
        mp.resize(siz);
        for (int i = 0; i < siz; i++)
        {
            mp[i].resize(siz);
            for (int j = 0; j < siz; j++)
            {
                mp[i][j] = 0;
            }
            if (isdw)
                mp[i][i] = 1;
        }
    }
    Matrix operator*(const Matrix &b)
    {
        Matrix res;
        res.init(max(size, b.size), p);
        for (int i = 0; i < size; i++)
        {
            for (int k = 0; k < size; k++)
            {
                for (int j = 0; j < size; j++)
                {
                    if (k >= b.size || j >= b.size)
                    {
                        continue;
                    }
                    res.mp[i][j] += mp[i][k] * b.mp[k][j];
                    if (res.p != -1)
                        res.mp[i][j] %= res.p;
                }
            }
        }
        return res;
    }
};
Matrix quick_pow_mat(Matrix a, ll b)
{
    Matrix res;
    res.init(a.size, a.p, 1);
    while (b)
    {
        if (b & 1)
            res = res * a;
        a = a * a;
        b >>= 1;
    }
    return res;
}
mt19937 rnd(random_device{}());
template <const int mod>
class static_mint
{
public:
    int mval = 0, minv = -1;
    static_mint()
    {
        mval = 0;
        minv = -1;
    }
    static_mint(int val)
    {
        this->mval = val % mod;
        this->minv = -1;
    }
    int val()
    {
        return mval;
    }
    int inv()
    {
        if (minv != -1)
            return minv;
        else
            return minv = qpow(mval, mod - 2, mod);
    }
    static_mint operator=(int b)
    {
        this->mval = b % mod;
        this->minv = -1;
        return *this;
    }
    operator int()
    {
        return int(mval);
    }
    operator ll()
    {
        return ll(mval);
    }
    operator double()
    {
        return (double)(mval);
    }
    operator float()
    {
        return (float)(mval);
    }
    bool operator!=(static_mint b)
    {
        return mval != b.val();
    }
    static_mint operator+(static_mint b)
    {
        return static_mint((1ll * mval + b.val()) % (ll)mod);
    }
    static_mint operator-(static_mint b)
    {
        int res = (1ll * mval - b.val()) % (ll)mod + mod;
        if (res >= mod)
            res -= mod;
        return static_mint(res);
    }
    static_mint operator*(static_mint b)
    {
        int res = 1ll * mval * b.val() % (ll)mod;
        return static_mint(res);
    }
    static_mint operator/(static_mint b)
    {
        int res = 1ll * mval * b.inv() % (ll)mod;
        return static_mint(res);
    }
    static_mint operator+=(static_mint b)
    {
        mval = (1ll * mval + b.val()) % (ll)mod;
        minv = -1;
        return *this;
    }
    static_mint operator-=(static_mint b)
    {
        mval = (1ll * mval - b.val()) % (ll)mod + mod;
        if (mval >= mod)
            mval -= mod;
        minv = -1;
        return *this;
    }
    static_mint operator*=(static_mint b)
    {
        mval = 1ll * mval * b.val() % (ll)mod;
        minv = -1;
        return *this;
    }
    static_mint operator/=(static_mint b)
    {
        mval = 1ll * mval * b.inv() % (ll)mod;
        minv = -1;
        return *this;
    }
    // ===========================
    // b's type = int
    static_mint operator+(int b)
    {
        return static_mint((1ll * mval + b) % (ll)mod);
    }
    static_mint operator-(int b)
    {
        int res = (1ll * mval - b) % (ll)mod + mod;
        if (res >= mod)
            res -= mod;
        return static_mint(res);
    }
    static_mint operator*(int b)
    {
        int res = 1ll * mval * b % (ll)mod;
        return static_mint(res);
    }
    static_mint operator/(int b)
    {
        int res = 1ll * mval * invll(b, mod) % (ll)mod;
        return static_mint(res);
    }
    static_mint operator+=(int b)
    {
        mval = (1ll * mval + b) % (ll)mod;
        minv = -1;
        return *this;
    }
    static_mint operator-=(int b)
    {
        mval = (1ll * mval - b) % (ll)mod + mod;
        if (mval >= mod)
            mval -= mod;
        minv = -1;
        return *this;
    }
    static_mint operator*=(int b)
    {
        mval = 1ll * mval * b % (ll)mod;
        minv = -1;
        return *this;
    }
    static_mint operator/=(int b)
    {
        mval = 1ll * mval * invll(b, mod) % (ll)mod;
        minv = -1;
        return *this;
    }
    bool operator!=(int b)
    {
        return mval != b;
    }
};
const int maxn = 2e5 + 5, maxm = 4e5 + 5;
int n, m;
int head[maxn];
struct EDGE
{
    int to, nxt;
} edge[maxm];
int cnt;
void add(int u, int to)
{
    edge[++cnt].to = to;
    edge[cnt].nxt = head[u];
    head[u] = cnt;
}
int indgree[maxn];
int l[maxn], r[maxn];
int pri[maxn];
void dfs(int u)
{
    if (pri[u])
        return;
    pri[u] = r[u];
    for (int i = head[u]; i; i = edge[i].nxt)
    {
        int to = edge[i].to;
        dfs(to);
        pri[u] = min(pri[u], pri[to] - 1);
    }
    if (l[u] > pri[u])
    {
        puts("No");
        exit(0);
    }
}
int ans[maxn];
vector<pii> rem;
void topo()
{
    set<pair<int, pii>> wait;
    set<pii> able;
    FOR(i, 1, n)
    {
        if (indgree[i] == 0)
        {
            wait.insert(make_pair(l[i], make_pair(r[i], i)));
        }
    }
    FOR(x, 1, n)
    {
    //    printf("x = %d\n",x);
        while (!wait.empty()&&wait.begin()->first <= x)
        {
            able.insert(wait.begin()->second);
            wait.erase(wait.begin());
        }
        if (able.empty())
        {
            puts("No");
            exit(0);
        }
        int u = able.begin()->second;
      //  printf("u = %d\n",u);
        ans[u] = x;
        able.erase(able.begin());
        for (int i = head[u]; i; i = edge[i].nxt)
        {
            int to = edge[i].to;
            indgree[to]--;
            if (indgree[to] == 0)
            {
                wait.insert(make_pair(l[to], make_pair(r[to], to)));
            }
        }
    }
    for(auto [s,t]:rem)
    {
        if(ans[s]>=ans[t])
        {
            puts("No");
            exit(0);
        }
    }
    puts("Yes");
    FOR(i,1,n)
    {
        printf("%d ",ans[i]);
    }
}
int main()
{
    read(n);
    read(m);
    FOR(i, 1, m)
    {
        int s, t;
        read(s);
        read(t);
        add(s, t);
        indgree[t]++;
        rem.emplace_back(make_pair(s,t));
    }
    FOR(i, 1, n)
    {
        read(l[i]);
        read(r[i]);
    }
    FOR(i, 1, n)
    {
        dfs(i);
    }
    topo();
    return 0;
}