<?php

/**
 * Class TwoSat
 * 2-SATを解きます。 変数 x_0, x_1, ･･･, x_{N - 1} に関して、
 * (x_i = f) ∨ (x_j = g)
 * というクローズを足し、これをすべて満たす変数の割当があるかを解きます。
 */
class TwoSat
{
    private int $n;
    private array $answer;
    private object $scc;

    /**
     * TwoSat constructor.
     * n変数の2-SATを作ります。
     * 計算量 O(n)
     * @param int $n 0 < n ≤ 10^8
     */
    function __construct(int $n)
    {
        $this->n = $n;
        $this->answer = array_fill(0, $n,false);
        $this->scc = new SCC(2 * $n);

    }

    /**
     * (x_i = f) ∨ (x_j = g) というクローズを足します。
     * 計算量　ならしO(1)
     * @param int $i 0 ≤ i < n
     * @param bool $f
     * @param int $j 0 ≤ i < n
     * @param bool $g
     */
    public function add_clause(int $i, bool $f, int $j, bool $g): void
    {
        assert(0 <= $i && $i < $this->n);
        assert(0 <= $j && $j < $this->n);
        $this->scc->add_edge(2 * $i + ($f ? 0: 1), 2 * $j + ($g ? 1 : 0));
        $this->scc->add_edge(2 * $j + ($g ? 0: 1), 2 * $i + ($f ? 1 : 0));

    }

    /**
     * 条件を足す割当が存在するかどうかを判定する。割当が存在するならばtrue、そうでないならfalseを返す。
     * 複数回呼ぶことも可能
     * 計算量　追加した制約の個数をmとして
     * O(n+m)
     * @return bool
     */
    public function satisfiable(): bool
    {
        $id = $this->scc->scc_ids()[1];
        for($i=0; $i < $this->n; $i++){
            if($id[2 * $i] === $id[2 * $i + 1]){
                return false;
            }
            $this->answer[$i] = $id[2 * $i] < $id[2 * $i + 1];
        }
        return true;
    }

    /**
     * 最後に呼んだ satisfiable の、クローズを満たす割当を返す。
     * satisfiable を呼ぶ前や、 satisfiableで割当が存在しなかったときにこの関数を呼ぶと、中身が未定義の長さ n の vectorを返す。
     * 計算量 O(n)
     * @return array
     */
    public function  answer():array
    {
        return $this->answer;
    }
}


/**
 * Class SCC
 * 有向グラフを強連結成分分解します。
 * TwoSatでも使用しているため、書き換える際は注意。
 * ref. AtCoder Library
 */
class SCC
{

    private int $n;
    private array $edges = [];
    private array $start;
    private array $elist;

    /**
     * MaxFlow constructor.
     * n 頂点 0 辺の有向グラフを作る。
     * 計算量 O(n)
     * @param int $n 0 ≤ n ≤ 10^8
     */
    function __construct(int $n)
    {
        $this->n = $n;
    }

    /**
     * 頂点fromから頂点toへ有向辺を足す。
     * 計算量 ならしO(1)
     * @param int $from 0 ≤ from < n
     * @param int $to 0 ≤ to < n
     */
    public function add_edge(int $from, int $to): void
    {
        assert(0 <= $from && $from < $this->n);
        assert(0 <= $to && $to < $this->n);
        $this->edges[] = [$from, $to];
    }

    public function csr(): void
    {
        $this->start = $this->elist =  array_fill(0, $this->n+1, 0);

        foreach($this->edges as $e){
            $this->start[$e[0] + 1]++;
        }
        for($i=1; $i<=$this->n; $i++){
            $this->start[$i] += $this->start[$i-1];
        }
        $counter = $this->start;
        foreach($this->edges as $e){
            $this->elist[$counter[$e[0]]++] = $e[1];
        }
    }

    public function scc_ids(): array
    {
        $this->csr();
        $now_ord = $group_num = 0;
        $visited = new SplDoublyLinkedList();
        $visited->setIteratorMode(SplDoublyLinkedList::IT_MODE_DELETE | SplDoublyLinkedList::IT_MODE_LIFO);
        $low = $ids = array_fill(0, $this->n, 0);
        $ord = array_fill(0, $this->n, -1);
        $dfs = function($v) use(&$now_ord, &$visited, &$ord, &$low, &$dfs, &$ids, &$group_num){
            $low[$v] = $ord[$v] = $now_ord++;
            $visited->push($v);
            for($i=$this->start[$v]; $i < $this->start[$v +1]; $i++) {
                $to = $this->elist[$i];
                if ($ord[$to] === -1) {
                    $dfs($to);
                    $low[$v] = min($low[$v], $low[$to]);
                } else {
                    $low[$v] = min($low[$v], $ord[$to]);
                }
            }
            if($low[$v] === $ord[$v]){
                while(true){
                    $u = $visited->pop();
                    $ord[$u] = $this->n;
                    $ids[$u] = $group_num;
                    if($u === $v){
                        break;
                    }
                }
                $group_num++;
            }
        };
        for($i=0;$i<$this->n; $i++){
            if($ord[$i] === -1){
                $dfs($i);
            }
        }
        foreach($ids as &$x){
            $x = $group_num - 1 - $x;
        }
        return [$group_num, $ids];

    }

    /**
     * 以下の条件を満たすような「頂点のリスト」のリストを返します。
     * ・全ての頂点がちょうど1つずつ、どれかのリストに含まれます。
     * ・内側のリストと強連結成分が一対一に対応します。リスト内での頂点の順序は未定義です。
     * ・リストはトポロジカルソートされています。異なる強連結成分の頂点 u, vu,v について、uu から vv に到達できる時、uu の属するリストは vv の属するリストよりも前です。
     * 計算量　追加した辺の本数をmとして
     * O(n+m)
     * @return array
     */
    public function scc():array
    {
        $ids = $this->scc_ids();
        $group_num = $ids[0];
        $counts =  array_fill(0,$group_num, 0);
        $groups = array_fill(0,$group_num, []);;
        foreach($ids[1] as $x){
            $counts[$x]++;
        }
        for($i=0;$i<$this->n;$i++){
            $groups[$ids[1][$i]][] = $i;
        }
        return $groups;
    }
}


[$N, $D] = fscanf(STDIN, "%d%d");
$X=$Y=[];
for($i=0; $i< $N; $i++){
    [$X[$i], $Y[$i]] = fscanf(STDIN, "%d%d");
}

$ts = new TwoSat($N);

for($i=0; $i < $N; $i++){
    for($j= $i + 1; $j < $N; $j++){
        if(abs($X[$i] - $X[$j]) < $D){
            $ts->add_clause($i, false, $j, false);
        }
        if(abs($X[$i] - $Y[$j]) < $D){
            $ts->add_clause($i, false, $j, true);
        }

        if(abs($Y[$i] - $X[$j]) < $D){
            $ts->add_clause($i, true, $j, false);
        }
        if(abs($Y[$i] - $Y[$j]) < $D){
            $ts->add_clause($i, true, $j, true);
        }
    }
}
if(!$ts->satisfiable()){
    echo "No";
    exit;
}
echo "Yes". PHP_EOL;
$ans = $ts->answer();
for($i=0;$i<$N;$i++) {
    if ($ans[$i]) {
        echo $X[$i] . PHP_EOL;
    } else {
        echo $Y[$i] . PHP_EOL;
    }
}

Measured memory_bytes: 17740