#include <bits/stdc++.h>

#define el '\n'
#define fi first
#define sec second
#define pb push_back
#define int long long
#define pii pair<int,int>
#define sz(v) (int)(v).size()
#define all(v) (v).begin(),(v).end()
#define FOR(i, a, b) for(int i = (a), _b = (b); i <= _b; i++)
#define REP(i, a, b) for(int i = (a), _b = (b); i >= _b; i--)

using namespace std;

const int INF = 0x3f3f3f3f3f3f3f3f;
const int MAX_K = 1e5;

pii a[MAX_K + 5];
int n, k;
pii st;

void Input(){
    cin >> n >> k >> st.fi >> st.sec;
    FOR(i, 1, k) cin >> a[i].fi >> a[i].sec;
}

namespace sub12{
//begin sub12
bool check_sub(){
    return k <= 10;
}

const int K = 10;
int dp[(1 << K) + 5][K + 5];

int get_dist(pii x, pii y){
    if(x.fi == y.fi || x.sec == y.sec) return 0;
    return min(abs(x.fi - y.fi), abs(x.sec - y.sec));
}

int walk(pii x, pii y){
    return abs(x.fi - y.fi) + abs(x.sec - y.sec);
}

int get_ans(pii pos){
    return min({walk(pos, {1, 1}),
               walk(pos, {1, n}),
               walk(pos, {n, 1}),
               walk(pos, {n, n})});
}

void Solve(){
    FOR(i, 0, k - 1) a[i] = a[i + 1];

    memset(dp, 0x3f, sizeof(dp));
    FOR(i, 0, k - 1) dp[1 << i][i] = get_dist(st, a[i]);

    vector<int> pos_one;
    FOR(mask, 1, (1 << k) - 1){
        FOR(bit, 0, k - 1) if(mask & (1 << bit)){
            pos_one.pb(bit);
        }

        for(int i : pos_one) for(int j : pos_one) if(i != j){
            dp[mask][i] = min(dp[mask][i], dp[mask ^ (1 << i)][j] + get_dist(a[j], a[i]));
        }
        pos_one.clear();
    }

    int ans = get_ans(st);
    FOR(mask, 1, (1 << k) - 1) FOR(i, 0, k - 1){
        ans = min(ans, dp[mask][i] + get_ans(a[i]));
    }
    cout << ans;
}
//end sub12
}

namespace sub3{
//begin sub3
bool check_sub(){
    return k <= 1000;
}

int get_dist(pii x, pii y){
    return min(abs(x.fi - y.fi), abs(x.sec - y.sec));
}

int walk(pii x, pii y){
    return abs(x.fi - y.fi) + abs(x.sec - y.sec);
}

int dist_ans(pii pos){
    return min({walk(pos, {1, 1}),
               walk(pos, {1, n}),
               walk(pos, {n, 1}),
               walk(pos, {n, n})});
}

vector<pii> g[MAX_K + 5];
int dist[MAX_K + 5];

void dijkstra(){
    memset(dist, 0x3f, sizeof(dist));
    priority_queue<pii, vector<pii>, greater<pii>> pq;

    pq.push({0, 0});
    dist[0] = 0;

    while(sz(pq)){
        int len = pq.top().fi;
        int u = pq.top().sec;
        pq.pop();

        if(len > dist[u]) continue;
        for(pii x : g[u]){
            int v = x.fi, w = x.sec;
            if(dist[v] > dist[u] + w){
                dist[v] = dist[u] + w;
                pq.push({dist[v], v});
            }
        }
    }
}

void Solve(){
    FOR(u, 1, k){
        g[0].pb({u, get_dist(st, a[u])});
        g[u].pb({k + 1, dist_ans(a[u])});

        FOR(v, u + 1, k){
            g[u].pb({v, get_dist(a[u], a[v])});
            g[v].pb({u, get_dist(a[u], a[v])});
        }
    }

    g[0].pb({k + 1, dist_ans(st)});
    dijkstra();
    cout << dist[k + 1];
}
//end sub3
}

namespace sub4{
//begin sub4
bool check_sub(){
    return true;
}

struct Node{
    pii pos;
    int id;
}ar[MAX_K + 5];

int get_dist(pii x, pii y){
    return min(abs(x.fi - y.fi), abs(x.sec - y.sec));
}

int walk(pii x, pii y){
    return abs(x.fi - y.fi) + abs(x.sec - y.sec);
}

int dist_ans(pii pos){
    return min({walk(pos, {1, 1}),
               walk(pos, {1, n}),
               walk(pos, {n, 1}),
               walk(pos, {n, n})});
}

vector<pii> g[MAX_K + 5];
int dist[MAX_K + 5];

void dijkstra(){
    memset(dist, 0x3f, sizeof(dist));
    priority_queue<pii, vector<pii>, greater<pii>> pq;

    pq.push({0, 0});
    dist[0] = 0;

    while(sz(pq)){
        int len = pq.top().fi;
        int u = pq.top().sec;
        pq.pop();

        if(len > dist[u]) continue;
        for(pii x : g[u]){
            int v = x.fi, w = x.sec;
            if(dist[v] > dist[u] + w){
                dist[v] = dist[u] + w;
                pq.push({dist[v], v});
            }
        }
    }
}

bool cmp_doc(const Node &x, const Node &y){
   return (x.pos.fi < y.pos.fi);
}

bool cmp_ngang(const Node &x, const Node &y){
    return (x.pos.sec < y.pos.sec);
}

void Solve(){
    FOR(i, 1, k) ar[i] = {a[i], i};

    FOR(i, 1, k){
        g[0].pb({ar[i].id, get_dist(st, ar[i].pos)});
        g[ar[i].id].pb({k + 1, dist_ans(ar[i].pos)});
    }


    sort(ar + 1, ar + k + 1, cmp_doc);
    FOR(i, 1, k - 1){
        g[ar[i].id].pb({ar[i + 1].id, get_dist(ar[i].pos, ar[i + 1].pos)});
        g[ar[i + 1].id].pb({ar[i].id, get_dist(ar[i].pos, ar[i + 1].pos)});
    }

    sort(ar + 1, ar + k + 1, cmp_ngang);
    FOR(i, 1, k - 1){
        g[ar[i].id].pb({ar[i + 1].id, get_dist(ar[i].pos, ar[i + 1].pos)});
        g[ar[i + 1].id].pb({ar[i].id, get_dist(ar[i].pos, ar[i + 1].pos)});
    }

    g[0].pb({k + 1, dist_ans(st)});
    dijkstra();
    cout << dist[k + 1];
}
//end sub4
}

signed main(){
    freopen("GAME.INP", "r", stdin);
    freopen("GAME.OUT", "w", stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    Input();

    if(sub12::check_sub()) return sub12::Solve(), 0;
    if(sub3::check_sub()) return sub3::Solve(), 0;
    if(sub4::check_sub()) return sub4::Solve(), 0;

    return 0;
}