#include <bits/stdc++.h>
using namespace std;
const int N = 1.5e5 + 5; 
const int D[8][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}, {-1, -1}, {1, 1}, {1, -1}, {-1, 1}}; 
const int V = 2e9; 

int n, TGFD; 
struct Point {
    int x, y; 
} a[N]; 

struct pair_hash {
    long long operator()(const pair<int, int> &p) const {
        return 1ll * p.first * V + p.second;
    }
};
unordered_map<pair<int, int>, int, pair_hash> id; 
vector<int> E[N]; 

int dfn[N], low[N], num, node, st[N], tot, cnt[N * 2], cut[N]; 
// vector<int> G[N * 2]; 
bool s2[N]; 
inline void tarjan(int x) {
    dfn[x] = low[x] = ++num; st[++tot] = x; 
    function<void(int, int)> addedge = [] (int x, int y) {
        ++cnt[x]; ++cnt[y]; 
        // G[x].emplace_back(y); 
        // G[y].emplace_back(x); 
    }; 
    for (int y : E[x]) 
        if (!dfn[y]) {
            tarjan(y); low[x] = min(low[x], low[y]); 
            if (dfn[x] <= low[y]) {
                int z; addedge(x, ++node); 
                do addedge(z = st[tot--], node); while (z != y); 
            }
        } else low[x] = min(low[x], dfn[y]); 
}

unordered_set<pair<int, int>, pair_hash> whiteqwq; 
unordered_map<pair<int, int>, int, pair_hash> white; 
set<int> ans; 
vector<pair<int, int>> todo; 

inline void dfs(pair<int, int> now) {
    if (whiteqwq.find(now) != whiteqwq.end()) return; 
    whiteqwq.emplace(now); todo.emplace_back(now); white[now] = 1; 
    for (int k = 0; k < 4; ++k) {
        int x = now.first + D[k][0], y = now.second + D[k][1]; 
        if (id.find({x, y}) != id.end()) {
            int val = id[{x, y}]; 
            s2[val] = 1; 
            if (!cut[val]) ans.insert(val); 
        }
    }
    for (int i = 0; i < 4; ++i) {
        pair<int, int> to = make_pair(now.first + D[i][0], now.second + D[i][1]); 
        if (white.find(to) != white.end()) dfs(to); 
    }
}
void dfs2(int x, int y, int val) {
    white[{x, y}] = val; 
    for (int k = 0; k < 4; ++k) {
        int _x = x + D[k][0], _y = y + D[k][1]; 
        if (white.find({_x, _y}) != white.end() && white[{_x, _y}] == 0) dfs2(_x, _y, val); 
    }
}

inline int ck(int i) {
    auto [x, y] = a[i]; 
    int ans = 0; 
    for (int i = 0; i < 8; ++i) {
        int xx = x + D[i][0], yy = y + D[i][1]; 
        if (id.find({xx, yy}) != id.end()) ++ans; 
    }
    return ans; 
}
inline void upd(int x, int k) {
    cut[x] = k; 
    if (k == 1) ans.erase(x); 
    else if (s2[x]) ans.insert(x); 
}

#ifdef BEF
void work(int x, int y) {
    // cerr << x << " " << y << "\n"; 
    for (int i = 4; i < 8; ++i) {
        int _x = x + D[i][0], _y = y + D[i][1]; 
        if (white.find({_x, _y}) == white.end() || white[{_x, _y}] != white[{x, y}]) continue; 
        int i1 = id.find({x + D[i][0], y}) == id.end() ? 0 : id[{x + D[i][0], y}], 
            i2 = id.find({x, y + D[i][1]}) == id.end() ? 0 : id[{x, y + D[i][1]}]; 
        if (!i1 || !i2) {
            if (i1) mp[i1] |= 0; 
            if (i2) mp[i2] |= 0; 
        } else {
            if (i1) {
                mp[i1] |= (ck(i1) >= 2); 
                // if (i1 == 8 && (ck(i1) >= 2)) {
                    // cerr << i1 << " " << i2 << " ???\n"; 
                    // cerr << _x << " " << _y << "\n"; 
                    // for (auto [pos, val] : white)   
                        // cerr << pos.first << " " << pos.second << " " << val << "\n"; 
                    // exit(-1); 
                // }
            }
            if (i2) {
                mp[i2] |= (ck(i2) >= 2); 
                // if (i2 == 8 && (ck(i2) >= 2)) {
                    // cerr << i1 << " " << i2 << " ???\n"; 
                    // cerr << _x << " " << _y << "\n"; 
                    // for (auto [pos, val] : white)   
                        // cerr << pos.first << " " << pos.second << " " << val << "\n"; 
                    // exit(-1); 
                // }
            }
        }
    }
    for (int i = 0; i < 4; ++i) {
        int _x = x + D[i][0] * 2, _y = y + D[i][1] * 2; 
        if (white.find({_x, _y}) == white.end() || white[{_x, _y}] != white[{x, y}]) continue; 
        _x = x + D[i][0], _y = y + D[i][1]; 
        if (id.find({_x, _y}) != id.end()) {
            if (D[i][0] == 0) { // 它是竖着的
                bool is = 1; 
                for (int dx : {-1, 1}) {
                    bool flg = 0; 
                    for (int dy : {-1, 0, 1})
                        if (id.find({_x + dx, _y + dy}) != id.end()) { flg = 1; break; }
                    if (!flg) { is = 0; break; }
                }
                mp[id[{_x, _y}]] |= is; 
                // upd(id[{_x, _y}], is); 
            } else {
                bool is = 1; 
                for (int dy : {-1, 1}) {
                    bool flg = 0; 
                    for (int dx : {-1, 0, 1})
                        if (id.find({_x + dx, _y + dy}) != id.end()) { flg = 1; break; }
                    if (!flg) { is = 0; break; }
                }
                mp[id[{_x, _y}]] |= is; 
                // upd(id[{_x, _y}], is); 
            }
        }
    }
}
#endif

bool whiteequal(int x, int y, int _x, int _y) {
    if (white.find({x, y}) == white.end()) return 0; 
    if (white.find({_x, _y}) == white.end()) return 0; 
    return white[{x, y}] == white[{_x, _y}]; 
}
bool check(int p) { // 检查 p 是否为割点
    if (ck(p) >= 2) {
        for (int i = 0; i < 8; ++i) {
            int x = a[p].x + D[i][0], y = a[p].y + D[i][1]; 
            if (id.find({x, y}) != id.end()) {
                int j = id[{x, y}]; 
                if (whiteequal(a[p].x + D[i][0], a[p].y, a[p].x, a[p].y + D[i][1])) return 1; 
            }
        }
    }
    for (int i = 0; i < 2; ++i) {
        if (!whiteequal(a[p].x + D[i][0], a[p].y + D[i][1], a[p].x - D[i][0], a[p].y - D[i][1])) continue; 
        if (D[i][0] == 0) {
            bool is = 1; 
            for (int dx : {-1, 1}) {
                bool flg = 0; 
                for (int dy : {-1, 0, 1})
                    if (id.find({a[p].x + dx, a[p].y + dy}) != id.end()) { flg = 1; break; }
                if (!flg) { is = 0; break; }
            }
            if (is) return 1; 
        } else {
            bool is = 1; 
            for (int dy : {-1, 1}) {
                bool flg = 0; 
                for (int dx : {-1, 0, 1})
                    if (id.find({a[p].x + dx, a[p].y + dy}) != id.end()) { flg = 1; break; }
                if (!flg) { is = 0; break; }
            }
            if (is) return 1; 
        }
    }
    return 0; 
}

int main(void) {
    // freopen("1.err", "w", stderr); 
    ios::sync_with_stdio(0); 
    cin >> n >> TGFD; 
    for (int i = 1; i <= n; ++i) {
        cin >> a[i].x >> a[i].y; 
        id[{a[i].x, a[i].y}] = i; 
    }
    if (n == 1) return cout << "YES\n1\n", 0; 
    for (int i = 1; i <= n; ++i)
        for (int k = 0; k < 8; ++k) {
            int x = a[i].x + D[k][0], y = a[i].y + D[k][1]; 
            if (id.find({x, y}) != id.end()) {
                int j = id[{x, y}]; 
                E[i].emplace_back(j); E[j].emplace_back(i); 
            }
        }
    node = n; tarjan(1); 
    for (int i = 1; i <= n; ++i) if (!dfn[i]) return cout << "NO\n", 0; 

    for (int i = 1; i <= n; ++i) if (cnt[i] != 1) cut[i] = 1; 

    pair<int, int> xxx = {-2e9, -2e9}; 
    for (int i = 1; i <= n; ++i)
        for (int k = 0; k < 8; ++k) {
            int x = a[i].x + D[k][0], y = a[i].y + D[k][1]; 
            if (id.find({x, y}) == id.end()) white[{x, y}] = 0, xxx = max(xxx, make_pair(x, y)); 
        }
    dfs(xxx); 
    int tot = 1; 
    for (int i = 1; i <= n; ++i)
        for (int k = 0; k < 8; ++k) {
            int x = a[i].x + D[k][0], y = a[i].y + D[k][1]; 
            if (white.find({x, y}) != white.end() && white[{x, y}] == 0) dfs2(x, y, ++tot); 
        }

    // cerr << "1622 is " << cut[1622] << "\n";  
    // for (int dy = -3; dy <= 3; ++dy, cerr << "\n")
        // for (int dx = -3; dx <= 3; ++dx) {
            // int x = a[1622].x + dx, y = dy + a[1622].y; 
            // if (id.find({x, y}) != id.end()) cerr << id[{x, y}] << " "; 
            // else if (whiteqwq.find({x, y}) != whiteqwq.end()) cerr << "W  "; 
            // else cerr << "-1 "; 
        // }

    vector<int> Ans; 
    for (int op = 1; op <= n; ++op) {
        assert(ans.size()); 
        int u = *ans.rbegin(); Ans.push_back(u); ans.erase(prev(ans.end())); 

#ifdef DEBUG
        cerr << "del " << u << "\n"; 
        if (u == 1622) exit(-1);
#endif

        id.erase(make_pair(a[u].x, a[u].y)); white[{a[u].x, a[u].y}] = 1; 

        // cerr << u << "\n"; 
        todo.clear(); dfs(make_pair(a[u].x, a[u].y)); 
        for (auto [x, y] : todo) {
            for (int i = 0; i < 8; ++i) {
                int _x = x + D[i][0], _y = y + D[i][1]; 
                if (id.find({_x, _y}) != id.end()) 
                    upd(id[{_x, _y}], check(id[{_x, _y}])); 
            }
        }

#ifdef DEBUG
        cerr << "1622 is " << cut[1622] << "\n";  
        for (int dy = -3; dy <= 3; ++dy, cerr << "\n")
            for (int dx = -3; dx <= 3; ++dx) {
                int x = a[1622].x + dx, y = dy + a[1622].y; 
                if (id.find({x, y}) != id.end()) cerr << id[{x, y}] << " "; 
                else if (white.find({x, y}) != white.end()) cerr << "W" << white[{x, y}] << " "; 
                else cerr << "-1 "; 
            }
#endif
#ifdef BEF
        mp.clear(); 
#endif

        // cerr << x << " " << y << "\n"; 
        // for (int i = 1; i <= n; ++i)
            // if (cut[i]) cerr << "CUT IS " << a[i].x << " " << a[i].y << "\n"; 
        // cerr << u << " " << cnt[u] << "\n"; 
        
        // cerr << "-----------\n"; 
    }
#ifdef DEBUG
    return 0; 
#endif
    reverse(Ans.begin(), Ans.end()); 
    cout << "YES\n"; 
    for (int i : Ans) cout << i << "\n"; 
    return 0; 
}

/*
-1  -1   W   232  -1   -1  228
-1  -1   W   W    332  862 1578
W   -1   W   W    1589 -1  -1
W   W    W   1622 -1   194 -1
107 1449 W   334  439  -1  817
849 -1   122 834  -1   -1  -1
-1  -1   -1  -1   -1   -1  207
*/

/*
W1  -1   -1   -1   -1   -1   -1 
W1  W1   W1   W1   W1   W1   -1 
694 701  1074 W1   526  W1   W1 
335 W187 W187 1622 W1   W1   643 
618 672  W187 W187 1378 1586 W1 
W1  W1   541  1213 W1   W1   W1 
W1  W1   W1   279  W1   W1   22 
*/